Datasets:

---

akumoth

/

peewee-issues

like 0

[]

[]

[ "Awesome thanks charles!\n" ]

[]

[]

[ "Can you define \"exploded\"?\n", "There is already the `SelectQuery.count()` method, which handles some edge-cases, so I'm loth to add another method that does the same thing.\n", "exploded = throws an exception\n\n> TypeError: object of type 'SelectQuery' has no len()\n\nit just felt like the query results object is an iterable container class that should implement the len() function so you can figure out how many results were returned prior to iterating through them. otherwise, you have to do something like\n\n```\nfor res in results:\n do_stuff_with_res(res)\n count += 1\nprint \"you have %d results\" % count\n```\n\nusing Select.count() requires that you either only want a count and not the resulting rows, or else that you have to use two queries. one snag i found:\n\n> Note that it is not uncommon for databases to report -1 after a select statement for performance reasons. (The exact number may not be known before the first records are returned to the application.) - https://code.google.com/p/pyodbc/wiki/Cursor\n\nthis might explain all the Travis failures\n", "There are quite a few test failures resulting from peewee checking the truthiness of the value.\n", "If you want the length of the result set, you can always do `len(list(query))`.\n\nI think I'm going to pass on merging this and mark wontfix.\n", "Why not adding this to SelectQuery:\n\n```\n def __len__(self):\n return self.count()\n```\n\nCalling `len` is very pythonic, and is missing imho.\n\n> If you want the length of the result set, you can always do len(list(query)).\n\nIs this issuing a count on db level, or python level?\n", "As I mentioned above, there are places that check the truthiness of a query variable. Adding a `__len__` method would cause the interpreter to use the query's count for the truth check.\n\nThis may be worth looking into, though.\n", "I looked again and whatever tests had been failing appear to have been fixed. I've added your changes.\n" ]

[]

[]

[]

[]

[]

[ "Peewee makes a point of not setting default DB values, so the current behavior is correct.\n", "was it too complicated to get right across platforms?\n", "My feeling was that it could lead to confusing behavior on the python side. If you really want it, you can always use SQL to accomplish default DB values, but it wasn't something I wanted to add to peewee.\n" ]

[]

[]

[ "That was an awesome response time! :-) Thanks so much!\n", "NP! I really appreciate the bug report.\n" ]

[]

[]

[ "I took a different approach that should work the same.\n", "Thanks for taking care of it!\n" ]

[]

[]

[ "Cool, thnx!\n" ]

[]

[]

[]

[]

[]

[ "Ouch, thanks! Will look into this after I get off work today.\n", "Should be fixed in f4481d14d8fc08b5c4c9964d7838af2866f021fd\n", "I'll re-push 2.4.6\n", "verified, thx!\n" ]

[]

[]

[ "Thanks!\n" ]

[]

[]

[ "The `db.create_table()` method will only create the table, not any of the indexes or constraints. To create a table for a model along with constraints, use `ModelClass.create_table()` or if creating multiple tables, `db.create_tables()`. I understand this is confusing and will update the docs to clarify the difference.\n", "I thank you for updating the documentation. Forgive my grumbling, but my programmer's heart is saddened by enshrining in code & doc different behaviors for functions that at first glance seem to be nearly identical, just one works on a single argument and the other on a list of arguments. \n", "There are historical reasons for this, but I do agree that it can be confusing. The documentation examples all should be showing either `Model.create_table()` or `Database.create_tables()`.\n" ]

[]

[]

[ "And by \"in our code\", I meant \"in our tests\"\n", "Interesting -- can you share any of the code or a representative example?\n", "I think perhaps 4c38abd5ea and #482 might be related.\n", "```\nclass Item(DateTimeModel, LocalizedModel, BaseModel):\n name_en = CharField()\n name_es = CharField(null=True)\n description_en = TextField(null=True)\n description_es = TextField(null=True)\n disclaimer_en = CharField(null=True)\n disclaimer_es = CharField(null=True)\n image_url = CharField(null=True)\n labels = JSONArrayField(null=True)\n status = CharField(choices=constants.STATUSES_FULL)\n style = ForeignKeyField(rel_model=Style)\n\nclass Category(DateTimeModel, LocalizedModel, BaseModel):\n parent = ForeignKeyField(rel_model='self', null=True)\n name_en = CharField()\n name_es = CharField(null=True)\n description_en = TextField(null=True)\n description_es = TextField(null=True)\n disclaimer_en = CharField(null=True)\n disclaimer_es = CharField(null=True)\n image_url = CharField(null=True)\n start_at = DateTimeField(null=True)\n end_at = DateTimeField(null=True)\n sort_order = FloatField(default=0)\n is_featured = BooleanField(default=False)\n status = CharField(choices=constants.STATUSES_FULL)\n\nclass CategoryItem(DateTimeModel, BaseModel):\n category = ForeignKeyField(rel_model=Category, on_delete='CASCADE', related_name=\"items\")\n item = ForeignKeyField(rel_model=Item, on_delete='CASCADE', related_name=\"categories\")\n sort_order = FloatField(default=0)\n\n class Meta:\n db_table = 'CategoryItem'\n primary_key = CompositeKey('category', 'item')\n\nclass StyleCategory(DateTimeModel, BaseModel):\n name = CharField()\n\nclass Style(DateTimeModel, BaseModel):\n id = IntegerField(primary_key=True, default=0)\n name = CharField()\n comments = TextField(null=True)\n status = CharField(choices=constants.STATUSES_FULL)\n category = ForeignKeyField(rel_model=StyleCategory)\n\nclass StyleVariant(DateTimeModel, LocalizedModel, BaseModel):\n id = IntegerField(primary_key=True, default=0)\n style = ForeignKeyField(rel_model=Style, on_delete='CASCADE', related_name='variants')\n name_en = CharField()\n name_es = CharField(null=True)\n\nitems = (\n sql.Item.select(\n sql.Item, sql.CategoryItem, sql.Category, sql.Style, sql.StyleVariant)\n .join(sql.CategoryItem, JOIN_LEFT_OUTER)\n .join(sql.Category, JOIN_LEFT_OUTER)\n .switch(sql.Item)\n .join(sql.Style)\n .join(sql.StyleVariant, JOIN_LEFT_OUTER)\n)\n\nwhere = []\nwhere.append(sql.Category.id == params[‘category_id'])\nitems = items.order_by(sql.CategoryItem.sort_order.asc())\n\nif where:\n items = items.where(reduce(operator.and_, where))\n\nitems = list(items.aggregate_rows())\n```\n", "I was hoping for something a little more compact..lol. But I think I've identified the issue and am working on tests/fixes.\n", "@jturmel -- I see that in your query you are doing:\n\n``` python\n .switch(sql.Item)\n .join(sql.Style)\n```\n\nBut I don't see a foreign key between Item and Style. How does this work?\n", "Sorry, was abstracting some of the business specifics...\n\nItem has (updated post above to reflect this):\n style = ForeignKeyField(rel_model=Style)\n", "I've got to be frank, your code you pasted does absolutely nothing to help me :)\n", "No problem, too little context:\n\n```\nclass Item(DateTimeModel, LocalizedModel, BaseModel):\n name_en = CharField()\n name_es = CharField(null=True)\n description_en = TextField(null=True)\n description_es = TextField(null=True)\n disclaimer_en = CharField(null=True)\n disclaimer_es = CharField(null=True)\n image_url = CharField(null=True)\n labels = JSONArrayField(null=True)\n status = CharField(choices=constants.STATUSES_FULL)\n style = ForeignKeyField(rel_model=Style)\n```\n", "No, I mean the whole block. It's massive with all sorts of extraneous fields. I don't know why it's creating the query dynamically, nor do I understand what the expected results are.\n", "@jturmel -- can you produce a _minimal_ example query that replicates the problem? I'm working on it on my end, but am having trouble replicating.\n", "Okay, here's a standalone test that uses Sqlite so should be easy to just run on your end.\n\nhttps://gist.github.com/jturmel/64f7527c4f225b591494\n\nRun under 2.4.4 = 1 query\nRun under 2.4.5 = 5 queries\n", "I'm running this with current peewee master and the test script runs without problems.\n", "Also thank you very much for distilling this down into a small example. I really appreciate it!\n", "EDIT: Actually nevermind, I get the error now. My bad.\n", "The plot thickens... I checked out version 2.4.4 and now instead of 5 queries I am getting 3:\n\n``` sql\n('SELECT \"t1\".\"id\", \"t1\".\"name\", \"t1\".\"style_id\", \"t2\".\"category_id\", \"t2\".\"item_id\", \"t2\".\"sort_order\", \"t3\".\"id\", \"t3\".\"parent_id\", \"t3\".\"sort_order\", \"t4\".\"id\", \"t4\".\"category_id\", \"t5\".\"id\", \"t5\".\"style_id\" FROM \"item\" AS t1 LEFT OUTER JOIN \"categoryitem\" AS t2 ON (\"t1\".\"id\" = \"t2\".\"item_id\") INNER JOIN \"style\" AS t4 ON (\"t1\".\"style_id\" = \"t4\".\"id\") LEFT OUTER JOIN \"stylevariant\" AS t5 ON (\"t5\".\"style_id\" = \"t4\".\"id\") LEFT OUTER JOIN \"category\" AS t3 ON (\"t2\".\"category_id\" = \"t3\".\"id\") WHERE (\"t3\".\"id\" = ?) ORDER BY \"t2\".\"sort_order\" ASC', [1])\n('SELECT \"t1\".\"id\", \"t1\".\"parent_id\", \"t1\".\"sort_order\" FROM \"category\" AS t1 WHERE (\"t1\".\"id\" = ?) LIMIT 1', [1])\n('SELECT \"t1\".\"id\", \"t1\".\"name\", \"t1\".\"style_id\" FROM \"item\" AS t1 WHERE (\"t1\".\"id\" = ?) LIMIT 1', [1])\n```\n\nI made some tweaks to the current version of Python and I am able to get 3 queries, but neither under 2.4.4 or 2.4.5 do I get just one.\n\nThe issue revolves around the way the CompositeKey interacts with the aggregate result wrapper. If I remove the `primary_key = CompositeKey(...)` line then I get a single query.\n\nIs it possible that you all changed that in your code and that's what is causing the test failure?\n", "We just upgraded from 2.4.4 to 2.4.5 to get the latest improvements/fixes\nfor other things and notices this regression and messed with it a bit to\ntry and figure out what was going on but without all the domain knowledge\nit's difficult to dive in so we just ended up rolling back to 2.4.4.\n\nNot sure why it's giving you 3 vs 1 (vs 5) -- the composite key is to\nenforce one of association of item to category (unique key)... any other\nthoughts/ideas?\n\nOn Sat, Jan 17, 2015 at 8:59 PM, Charles Leifer [email protected]\nwrote:\n\n> The plot thickens... I checked out version 2.4.4 and now instead of 5\n> queries I am getting 3:\n> \n> ('SELECT \"t1\".\"id\", \"t1\".\"name\", \"t1\".\"style_id\", \"t2\".\"category_id\", \"t2\".\"item_id\", \"t2\".\"sort_order\", \"t3\".\"id\", \"t3\".\"parent_id\", \"t3\".\"sort_order\", \"t4\".\"id\", \"t4\".\"category_id\", \"t5\".\"id\", \"t5\".\"style_id\" FROM \"item\" AS t1 LEFT OUTER JOIN \"categoryitem\" AS t2 ON (\"t1\".\"id\" = \"t2\".\"item_id\") INNER JOIN \"style\" AS t4 ON (\"t1\".\"style_id\" = \"t4\".\"id\") LEFT OUTER JOIN \"stylevariant\" AS t5 ON (\"t5\".\"style_id\" = \"t4\".\"id\") LEFT OUTER JOIN \"category\" AS t3 ON (\"t2\".\"category_id\" = \"t3\".\"id\") WHERE (\"t3\".\"id\" = ?) ORDER BY \"t2\".\"sort_order\" ASC', [1])\n> ('SELECT \"t1\".\"id\", \"t1\".\"parent_id\", \"t1\".\"sort_order\" FROM \"category\" AS t1 WHERE (\"t1\".\"id\" = ?) LIMIT 1', [1])\n> ('SELECT \"t1\".\"id\", \"t1\".\"name\", \"t1\".\"style_id\" FROM \"item\" AS t1 WHERE (\"t1\".\"id\" = ?) LIMIT 1', [1])\n> \n> I made some tweaks to the current version of Python and I am able to get 3\n> queries, but neither under 2.4.4 or 2.4.5 do I get just one.\n> \n> The issue revolves around the way the CompositeKey interacts with the\n> aggregate result wrapper. If I remove the primary_key = CompositeKey(...)\n> line then I get a single query.\n> \n> Is it possible that you all changed that in your code and that's what is\n> causing the test failure?\n> \n> —\n> Reply to this email directly or view it on GitHub\n> https://github.com/coleifer/peewee/issues/503#issuecomment-70394533.\n", "The problem had to do with the composite primary key. When building the identity map, peewee asks for the primary keys of the constructed instances (to map them back later when constructing the model graph). The problem was that getting the PK value of a composite key field was resolving the foreign keys, triggering 2 extra queries per iteration (one for the category and one for the item). Since there's two iterations, 4 extra queries.\n\nI fixed this by forcing peewee to use the raw field data when mapping composite keys, avoiding the extra lookups.\n", "Great!\n\nFTR, just now I created an entirely new Python env, installed nose and peewee 2.4.4 and was able to see the 3 vs 5 query (as opposed to 1 vs 5 I was seeing in our site's environment) -- that said it's probably not worth figuring out the difference there as it looks like you've figured it out.\n\nThink there should be tests like what I sent as a case so there aren't future regressions on this specifically?\n", "Yeah, see 6fb024372cc77ccae47fb04624840bbee1a84df6\n" ]

[]

[]

[ "Yeah, it's currently only in master. I will be pushing a new version soon which will contain the field.\n" ]

[]

[]

[ "A single file, that's all you need!\n\nIf it were to get to 10K lines I would consider splitting it up, but I don't imagine it will get that big. The code is also already broken up into the core and the `playhouse` extensions collection.\n\nLook around at sqlalchemy, you'll see a number of 3K line files. Django has several 1K+ line files.\n", "My experience of new comer is that this is not so welcoming:\n- I'm missing an overview of the API structure: who inherits who? which logical groups do we have (Model, Fields, Query, Database…)? Where should I go to understand this piece of logic?\n- each time a search for something in the code, I'm missing the context (which class am I? Where in the class hierarchy?)\n- my _own_ perception is that files bigger than around 1k lines are bad practice (mainly for readability, i.e. reasons exposed before), so seeing this huge file made me a bit reluctant being confident in peewee as a serious project when I first considered it for a new project I'm starting\n\nAlso, I'd suggest to namespace `playhouse` (and call it something more expected like \"extras\" or \"extensions\"). I've been reluctant using playhouse module at the first time, because the name suggested me it was more about `playground` or `examples` actual extensions. Also, I was more or less feeling peewee was more of a POC/pet project because of that.\n\nMy two cents… ;)\n", "Peewee has always been a single module. It will remain that way. Honestly there are very few concepts in peewee, and if you read through the entire source, you will have a good grasp on it. Projects that are big, like some other orms, you can't reasonably read. And there's no cohesive order, either. Peewee reads like a book, in order.\n\nGood point about playhouse, need to make it clear those are extensions.\n", "Not to start again the discussion, but for the record: one other drawback about the single file package I've run into: git(hub) blame and history are very noisy because all changes are in the same file, and thus imho hardly usable.\n" ]

[]

[]

[ "What do the dates in your table look like? Can you show me some examples?\n", "it's\n15/01/2015 22:15\n", "OK, that's the problem. You'll need to subclass `DateTimeField` and specify the `formats` parameter, e.g.\n\n``` python\nclass CustomDateTimeField(DateTimeField):\n formats = ['%d/%m/%Y %H:%M'] + DateTimeField.formats\n```\n" ]

[]

[]

[ "Can you please format your issue? You can edit it and apply markdown style.\n", "If a model has an auto-increment integer primary key named `id`, the convention is to omit defining it explicitly. This convention comes from Django and I like it. If you want to fix it, just add this field definition to your models:\n\n``` python\nid = PrimaryKeyField()\n```\n\nAlso I see in your schema the foreign keys are `NOT NULL` but in peewee they are marked `null=True` -- you might want to remove that.\n" ]

[]

[]

[ "When will be next release?\n", "I'll create one soon.\n" ]

[]

[]

[ "I'm not exactly sure I understand what problem, specifically, you are encountering.\n", "@coleifer, I made an example for you to understand:\n\n``` python\nfrom peewee import *\nfrom threading import Thread\nfrom random import random, randint\n\nimport os\n\nDB_FILE = 'db.sqlite'\n\nif os.path.isfile(DB_FILE):\n os.remove(DB_FILE)\n\ndb = SqliteDatabase(DB_FILE, threadlocals=True)\n\n\n# Next comes the creation of tables and filling.\nclass Products(Model):\n id = IntegerField(index=True, primary_key=True)\n count_sales = IntegerField()\n updated = IntegerField() # default to zero\n\n class Meta:\n database = db\n\ndb.connect()\ndb.create_tables([Products]) # I have several tables\n\ndata = []\nfor _ in range(0, 40):\n data.append({'count_sales': randint(2, 9), 'updated': 0})\n\nwith db.transaction():\n for data_dict in data:\n Products.create(**data_dict)\n\nprint('Count products: {}\\n'.format(Products.select().count()))\n\n\ndef products_update(n, tables, db):\n Products, = tables\n\n count = Products.select().where(Products.count_sales < 10, Products.updated == 0).count()\n print('Thread #{}, {} records found'.format(n, count))\n if count:\n row = Products.select().where(Products.count_sales < 10, Products.updated == 0).order_by(random()).limit(1).get()\n\n Products.update(updated=1).where(Products.id == row.id).execute()\n\n\nclass MyThread(Thread):\n n = None\n tables = None\n db = None\n\n def run(self):\n products_update(self.n, self.tables, self.db)\n\nfor n in range(1, 5):\n t = MyThread()\n t.tables = (Products,)\n t.db = db\n t.n = n\n t.start()\n\n# Result:\n# --------------------\n# Count products: 40\n#\n# Thread #1, 40 records found\n# Thread #2, 40 records found\n# Thread #3, 40 records found\n# Thread #4, 39 records found\n```\n", "And I need the result to be consistent:\n\n```\n# Thread #1, 40 records found\n# Thread #2, 39 records found\n# Thread #3, 38 records found\n# Thread #4, 37 records found\n```\n", "I appreciate you're spending the time creating this issue, but this isn't the appropriate place for this type of question. Try StackOverflow?\n", "@coleifer Tried, they could not help. Can you tell me where to dig?\n", "I'm failing to see how this is a peewee issue and not an issue of incorrect use of locks or incorrect assumptions about concurrent behavior.\n" ]

[]

[]

[ "Yes! I'm very interested in adding this. I currently have 9.3.5 installed so I'll need to get 9.4 running in order to start working on this.\n", "0f48020cf2604966aa77dcd57044b738cc7f44de\n", "I've made a start at implementing this. I'll put together some docs shortly.\n", ":thumbsup:\n", "Any update on this issue @coleifer ???\n", "Support was merged in.\n" ]

[]

[]

[ "This is one of many reasons why default ordering is a bad idea. I regret adding this functionality, but it's too late to remove it now.\n\nAt any rate, you can clear the existing order by clauses on your sub-queries. That should fix the problem:\n\n``` python\nq_orders = cls.select(Type, Order.quantity).join(Wine).join(Order).\\\n where(Type.owner == login.current_user.id).group_by(Type.id).\\\n order_by()\nq_changes = cls.select(Type, fn.sum(ChangeLog.change).alias('quantity')).\\\n join(Wine).join(Order).join(ChangeLog).\\\n where(Type.owner == login.current_user.id).group_by(Type.id).\\\n order_by()\n```\n" ]

[]

[]

[ "I'm confused -- why is `host` getting used?\n", "Hum i read the doc too rapidly and confused relatif/absolute path. please discard this PR. sorry for the noise.\n\nWas trying to fix this kind of error\n\n```\nself = <peewee.SqliteDatabase object at 0x7fc15db82c90>\ndatabase = 'tmp/file.db', kwargs = {}\n\ndef _connect(self, database, **kwargs):\n> conn = sqlite3.connect(database, **kwargs)\nE OperationalError: unable to open database file\n```\n\nbut the doc is right. furthermore, this fix doesnt cover the use case (absolute path...)\n" ]

[]

[]

[ "What database engine are you using? That's definitely a bit odd.\n", "If you're using SQLite, you will need to execute `PRAGMA foreign_keys=on;` when you open a connection in order for this to work correctly.\n", "Thank you. I am using SQLite, and this seems to be the solution. :+1:\n", "The problem persists.\n\nTried executing `PRAGMA foreign_keys=on;` using Flasks `before_request` decorator like this\n\n```\[email protected]_request\ndef before_request():\n g.db = db\n g.db.execute_sql('PRAGMA foreign_keys=on')\n g.db.connect()\n```\n\nThe problem still persists.\n", "You just need to swap so you execute the pragma statement **on** the new connection.\n\n``` python\n g.db = db\n g.db.connect()\n g.db.execute_sql('PRAGMA foreign_keys=on')\n```\n\nAlternatively you could subclass `SqliteDatabase`:\n\n``` python\n\nclass SqliteFKDatabase(SqliteDatabase):\n def _add_conn_hooks(self, conn):\n super(SqliteFKDatabase, self)._add_conn_hooks(conn)\n self.execute_sql('PRAGMA foreign_keys=on;')\n```\n", "This seems not like a SQLite specific issue. Tried using MySQL too. The problem still persists. \nWondering wether my model is right. Also `delete_instance()` is enough right?\n", "``` python\nfrom peewee import *\n\ndb = SqliteDatabase(':memory:')\ndb.execute_sql('pragma foreign_keys=on;')\n\nclass Base(Model):\n class Meta:\n database = db\n\nclass A(Base):\n data = IntegerField(default=0)\n\nclass B(Base):\n a = ForeignKeyField(A, on_delete='CASCADE')\n\ndb.create_tables([A, B])\n\na1 = A.create()\na2 = A.create()\nfor a in [a1, a2]:\n for i in range(3):\n B.create(a=a)\n\nprint B.select().count()\na1.delete_instance()\nprint B.select().count()\n```\n\nPrints:\n\n```\n6\n3\n```\n", "Thank you. I had got the concept wrong. \nEvery thing is fine now :+1:\n" ]

[]

[]

[ "You should not specify `primary_key=True` if you are specifying a `CompositeKey`. Instead write:\n\n``` python\nclass A(BaseModel):\n id1 = IntegerField()\n id2 = IntegerField()\n\n class Meta:\n db_table = 'a'\n primary_key = CompositeKey('id1', 'id2')\n```\n", "Oh shit, should have read this more closely. You're right.\n" ]

[]

[]

[ "Thank you!\n" ]

[]

[]

[ "Closing this, looks like a https://github.com/spulec/freezegun issue with PyPy.\n" ]

[]

[]

[ "You need to close connections when you're done with them. Neither pymysql nor peewee will detect the 2013/2006 error and re-connect automatically.\n", "If you're using the connection pool, then when you close a connection it will be returned to the pool and recycled until it reaches it's stale timeout (specified when initializing the pool).\n\n``` python\n\ndb = PooledMySQLDatabase('my_db', stale_timeout=300) # Consider a conn stale after 5 mins.\n\ndb.connect()\n# do some stuff.\ndb.close() # Return connection to the pool.\n```\n", "Ok. I didn't realize I had to manually connect and close database connections. That makes sense. Thanks a lot!\n\nI do realize this is a very newbie kind of problem, but maybe you could put some more emphasis on this in the documentation - possibly in the quickstart section.\n\nAnyways, thanks for the great ORM! Your work is very much appreciated!\n", "Yeah, while I have added some documentation to this effect, it could certainly stand to be improved. You're not the first person to find this confusing, so I'll make a point to clean up the docs.\n", "\n", "Explicitly putting the db.connect() and db.close() statements in some example code might help make the point clear. I noticed that this is shown in the \"Example app\" page in the documentation. But, I hadn't read it until now, because I use cherrypy and I thought the \"Example app\" page was flask specific and not relevant to me. I was mostly going through the \"API Reference\", \"Managing your Database\" and \"Quickstart\" sections of the documentation to try and figure out what had happened.\n", "good idea\n" ]

[]

[]

[ "``` python\n class Meta:\n indexes = (\n (('vorname', 'nachname', 'gesamtbrutto'), True), # Add trailing comma.\n )\n```\n" ]

[]

[]

[]

[]

[]

[]

[]

[]

[ "There's now a `stable` branch with corresponding docs. I will keep the `stable` branch pinned to the latest tag:\n\nhttp://docs.peewee-orm.com/en/stable/\n" ]

[]

[]

[ "Thanks a lot. I'm sorry for all the pull requests and stuff. These are just the issues I've found thus far in using your ORM in a personal project of mine, and I thought it'd be nice to share them so others don't run into the same =)\n", "No, I appreciate it! Thanks for your help!\n", "Sure! =)\n" ]

[]

[]

[ "Refs #480\n", "Your options proposed there do make sense! Performing a separate query isn't that big of an issue given that the usage of get() implies there will only be one parent object. However, in the case that you're joining on many different tables, I suppose you'd need a separate query for each of them, or use the [0] option as I did in #484.\n\nPlease note that #484 is not dependent on single row selects, however, as it can apply to selecting all rows with an Expression-based join.\n" ]

[]

[]

[ "I fixed this with a slightly smaller change: 4c38abd5ea1c0d05226e181fced3895ada8ee73d\n", "I took a look. Awesome!\n" ]

[]

[]

[ "Related names are \"back references\", a handy way of accessing a collection of objects relating _to_ the given instance. For example say you have user and tweet models. You would say a tweet has one user, while a user has many tweets. That gives you a foreign key named user and a related name of tweets:\n\n``` python\nclass User(Model):\n username = CharField()\n\nclass Tweet(Model):\n user = ForeignKeyField(User, related_name='tweets')\n content = TextField()\n```\n\nThis will patch a new attribute onto the user model named `tweets`. If the `User` already had a field named `tweets`, though, then peewee would not like it because the related name attribute it's trying to add is taken.\n\nThat's one part of the issue. To fix this, I would suggest calling your related_name \"res_users\":\n\n``` python\nclass ResUsers(BaseModel):\n #gave up here... it reference to self, but have same error\n create_uid = peewee.IntegerField()\n\nclass ProductPriceType(BaseModel):\n class Meta:\n managed = False\n db_table = 'product_price_type'\n\n create_uid = peewee.ForeignKeyField(ResUsers, null=True, related_name=\"res_users\")\n```\n\nTo create a self-referential foreign key, you can do:\n\n``` python\nclass ResUsers(BaseModel):\n create_uid = peewee.ForeignKeyField('self', related_name='users_created')\n```\n\nDocumentation:\n- http://docs.peewee-orm.com/en/latest/peewee/models.html#self-referential-foreign-keys\n- http://docs.peewee-orm.com/en/latest/peewee/api.html#ForeignKeyField\n\nPlease let me know if this does not address your question.\n", "Looks like I've understood difference between django ORM and Peewee in this part. \nWill update ticket, if something will go wrong. Thanks. \n" ]

[]

[]

[ "`aggregate_rows()` was not really intended, when I wrote it, for fetching single instances via `.get()`. Can you explain your specific use case? I might be able to suggest some equally viable alternatives.\n", "We have an alternative, we just don't use .get(), we just run the normal \"list\" query, check to see if there are any results, and pick off the first result, it's just not as elegant as using .get() and catching the peewee.DoesNotExist exception\n\nUsing an example from the docs: http://peewee.readthedocs.org/en/latest/peewee/quickstart.html\n\n``` python\n>>> subquery = Pet.select(fn.COUNT(Pet.id)).where(Pet.owner == Person.id).\n>>> person = (Person\n... .select(Person, Pet, subquery.alias('pet_count'))\n... .join(Pet, JOIN_LEFT_OUTER)\n... .order_by(Person.name)\n... .where(Person.id == 1)\n... .aggregate_rows()\n... .get())\n\n... print person.name, person.pet_count, 'pets'\n... for pet in person.pets:\n... print ' ', pet.name, pet.animal_type\n```\n", "So the `.get()` helper works efficiently by calling `LIMIT 1`. `aggregate_rows()` does not work well with `LIMIT` because the data is de-duped and aggregated (hence aggregate_rows) on the python side. Also note the row**s** -- it is intended to work with multiple rows of data.\n\nYou can still achieve what you're going for in O(1) queries, you'll just need to make 2 instead of 1:\n\n``` python\nperson = Person.get(Person.id == 1)\npets = Pet.select().where(Pet.owner == person)\n# or\npets = person.pets\n```\n\nIn addition to being roughly equivalent in terms of performance, this is probably quite a bit more efficient than `aggregate_rows()`.\n\nNote: I edited your comment to fix the syntax highlighting.\n", "Do you have any additional questions or thoughts? If not, I will go ahead and close the issue.\n", "Definitely understand, that's fine on closing it.\n\nIt does seem like .get() could just be intelligent enough that if .aggregate_rows() is set on the query that it drops the LIMIT 1, that way aggregate rows still collects the records under the single record but the case where they don't use aggregate_rows() is still optimal.\n", "Yeah, it would be possible, but I'm loth to introduce special-cases. Particularly because, in my mind, the use-cases for `.get()` and `.aggregate_rows()` are quite different. With `.get()` you have some piece of information to uniquely identify a row, so you're already looking at O(1). Whereas with `.aggregate_rows()` you're looking to grab multiple rows and avoiding the dreaded N+1 query problem. Since `.get()` already implies you don't have N+1, I think it's acceptable to avoid special-casing.\n\nThat said, I will update the docs to make this clear. Thanks for reporting the issue!\n" ]

[]

[]

[ "> Is this an issue or are we just using it wrong ? :)\n\nYes, it appears to be! Thanks for bringing this to my attention. I'll look into fixing this tonight after work.\n" ]

[]

[]

[ "I didn't think about Tornado when writing that, to be honest. The connections are stored in a heap on the pooled database instance, so there's no reason why a single-threaded app could not check out multiple connections. There's a catch, though...\n\nThe database stores the connection on a threadlocal. So if you had a multi-threaded app, each thread would have it's own connection (which would be managed by the pool). In a single-threaded app using an event-loop, how would peewee know which connection belongs with which callback?\n", "I checked again, and found single-threaded app could check out multiple connections.\n\nBut for things like `transaction`, which stores the info in `threadlocal` variable.\nFor single thread app, this kind of `transaction` would not work, as all the transactions are within the same `threadlocal`.\n\nIs this one the catch which should be taken care?\n", "> I checked again, and found single-threaded app could check out multiple connections.\n\nOh really? I would have thought that calling `db.get_conn()` in a single-threaded app would always yield the same connection. Were you using a different API than `get_conn()`?\n", "I just thought the `PooledDatabase _connect()` could create multi connections.\nBut the `get_conn()` could only get the same connection, I think.\n\nBTW: The transaction part will not work in single-thread app, isn't it?\n", "> I just thought the PooledDatabase _connect() could create multi connections.\n> But the get_conn() could only get the same connection, I think.\n\nRight, the `_connect()` method will create new connections, but that is a private API and will not actually work how you think it will.\n\nThe database instance your app uses has a threadlocal (`__local`) that stores the currently active connection (or None if no conn is open yet). Whenever you use a model or the db to execute a query, the db will call `self.get_conn()` to get the connection stored on the threadlocal, creating one if one does not exist.\n\nSo while you can open as many connections as you want, the database will only use the one stored on the threadlocal.\n", "I'm closing the issue as this is not really a bug, but if you have more questions or would like to discuss, feel free to continue commenting.\n", "But for single-thread app, this `__local` actually becomes a shared variable.\nThen does it mean, things like `transaction(object)`and `get_conn()` which assume the `__local` is private to each client thread, would not work as desired?\n", "> But for single-thread app, this __local actually becomes a shared variable. Then does it mean, things like transaction(object)and get_conn() which assume the __local is private to each client thread, would not work as desired?\n\nExactly. For a single-threaded application, it acts like an instance attribute, and since there is only a single database instance, there will only be a single connection.\n", "Thanks for your time and great classification.\n", "My pleasure! I hope I've helped, or at least explained the limitations of the code.\n" ]

[]

[]

[]

[]

[]

[ "It sounds like this is more of a SQL question than an issue with peewee, so I'm going to close.\n", "@coleifer sorry, I was looking for something simple API without subquery to do this with peewee.\n" ]

[]

[]

[ "That's odd, I copy/pasted the code into a module locally and it ran without issue, although I did modify the code slightly so the call to `drop_column()` referred to `mytable` and not `mytable2`. I also explicitly checked out the 2.4.4 tag.\n\nCan you do some debugging to find out what values are being passed to `cursor.execute()`?\n", "Sorry, I didn't notice that `2`, which in my case referred to an old existing table and in your case referred to a non existing table.\n\nMy old table had a primary key and an indexed column, and it looks like that's what changes the behavior between the two versions.\n\nThe following code reproduces the problem starting from an empty database.\n\n```\nimport peewee\nimport playhouse.migrate\ndb = peewee.SqliteDatabase('test.db', threadlocals=True)\n\nclass MyTable(peewee.Model):\n pk = peewee.CharField(primary_key=True)\n mycolumn = peewee.CharField(index=True)\n class Meta:\n database = db\n\ndef create_table():\n MyTable.drop_table(True)\n MyTable.create_table()\n\nmigrator = playhouse.migrate.SqliteMigrator(db)\n\ncreate_table()\ntry: playhouse.migrate.migrate(migrator.drop_column('mytable', 'mycolumn'))\nexcept: print('1) error with good db and good column')\n\ncreate_table()\ntry: playhouse.migrate.migrate(migrator.drop_column('notable', 'mycolumn'))\nexcept: print('2) error with bad db and good column')\n\ncreate_table()\ntry: playhouse.migrate.migrate(migrator.drop_column('mytable', 'nocolumn'))\nexcept: print('3) error with good db and bad column')\n\ncreate_table()\ntry: playhouse.migrate.migrate(migrator.drop_column('notable', 'nocolumn'))\nexcept: print('4) error with bad db and bad column')\n```\n\nOutput with 2.3.3:\n\n```\n2) error with bad db and good column\n4) error with bad db and bad column\n```\n\nOutput with 2.4.4:\n\n```\n1) error with good db and good column\n2) error with bad db and good column\n3) error with good db and bad column\n4) error with bad db and bad column\n```\n\nThe traceback on the first error is:\n\n```\nTraceback (most recent call last):\n File \"F:\\eclipse\\plugins\\org.python.pydev_2.8.2.2013090511\\pysrc\\pydevd_comm.py\", line 773, in doIt\n result = pydevd_vars.evaluateExpression(self.thread_id, self.frame_id, self.expression, self.doExec)\n File \"F:\\eclipse\\plugins\\org.python.pydev_2.8.2.2013090511\\pysrc\\pydevd_vars.py\", line 376, in evaluateExpression\n result = eval(compiled, updated_globals, frame.f_locals)\n File \"<string>\", line 1, in <module>\n File \"C:\\Python34\\lib\\site-packages\\playhouse\\migrate.py\", line 535, in migrate\n operation.run()\n File \"C:\\Python34\\lib\\site-packages\\playhouse\\migrate.py\", line 144, in run\n getattr(self.migrator, self.method)(*self.args, **kwargs))\n File \"C:\\Python34\\lib\\site-packages\\playhouse\\migrate.py\", line 135, in _handle_result\n result.run()\n File \"C:\\Python34\\lib\\site-packages\\playhouse\\migrate.py\", line 144, in run\n getattr(self.migrator, self.method)(*self.args, **kwargs))\n File \"C:\\Python34\\lib\\site-packages\\playhouse\\migrate.py\", line 138, in _handle_result\n self._handle_result(item)\n File \"C:\\Python34\\lib\\site-packages\\playhouse\\migrate.py\", line 133, in _handle_result\n self.execute(result)\n File \"C:\\Python34\\lib\\site-packages\\playhouse\\migrate.py\", line 129, in execute\n self.migrator.database.execute_sql(sql, params)\n File \"C:\\Python34\\lib\\site-packages\\peewee.py\", line 2780, in execute_sql\n cursor.execute(sql, params or ())\nValueError: operation parameter must be str\n```\n\nThe `cursor.execute()` on line 2780 is executed with the following parameters:\n\n```\nsql, params\n('select name, sql from sqlite_master where type=? and LOWER(name)=?', ['table', 'mytable'])\n```\n\nthen the execution goes to the `else` block and crashes at the `self.commit()` on line 2788. (I don't understand why the 2780 is reported in the traceback)\n", "Because you have a non-integer primary key, sqlite will automatically create an index. The index is found when introspecting the db, but it has no associated SQL, so we're unable to re-create it (which is fine, because SQLite will re-create it anyways).\n", "The issue is not an issue for me. I reported because often a difference between two versions is a red flag. \nIt's up to you to close it or fix it (assuming that there is something to fix)\n\nThank you!!!!!!\n", "> It's up to you to close it or fix it (assuming that there is something to fix)\n\nI did fix it. In b0c866c\n" ]

[]

[]

[ "@coleifer Wow, thank you for super quick fix! :smiley: \n\nI've noticed adding `ForeignKeyField` produces `REFERENCES` that is inline with column definition:\n\n```\n\"network_id\" INTEGER REFERENCES \"network\" (\"id\")\n```\n\nvs what happens when you call `.create_table()`:\n\n```\n\"network_id\" INTEGER, FOREIGN KEY (\"network_id\") REFERENCES \"network\" (\"id\")\n```\n\nThese two forms seem to be equivalent. Am I right?\n\nI'm writing about it, because I didn't know about the first form. May be this thread would help people who could be confused by it :)\n", "They are equivalent and unfortunately that is the only way to do it in one shot with SQLite. The way I'd prefer is with and `ALTER/ADD COLUMN`, then `ALTER/ADD CONSTRAINT`. Since SQLite does not support this, I just inlined the foreign key definition.\n", "@coleifer Because I didn't know about inline `REFERENCES`, I've tried to implement `FOREIGN KEY` manipulation by creating a new table and copying data into it. (Reusing and extending `SqliteMigrator` `_update_column` method.) But my code quickly became ugly, I switched to other things. And on the next day you've fixed it with a much better approach :) \n" ]

[]

[]

[ "Thank you!\n" ]

[]

[]

[ "Thank you!\n" ]

[]

[]

[ "Oh wow, nice catch!\n", "Thanks a lot! ^_^ When do you think this will see the light of pip? =O\n" ]

[]

[]

[ "> Also for unknown reasons id(self) in connect differs from id(db) in app.py.\n> Not sure why..\n\nI think this is the problem, and I'm not sure how it could be a peewee issue.\n\n``` python\nfrom peewee import *\n\ndb = SqliteDatabase(None)\n\nclass User(Model):\n username = CharField()\n\n class Meta:\n database = db\n\[email protected]_on_success\ndef create(username):\n User.create(username=username)\n\ndb.init(':memory:')\nUser.create_table()\n\ncreate('hello')\ncreate('charlie')\n\nfor user in User.select():\n print user.username\n```\n\nThis code works fine.\n", "Yes it does..\n\nI've cut everything and found minimal code for reproduce:\n\n**A. Does not work: two files.**\n\nThe first one\n\n```\n# test.py\n# -*- coding: utf-8 -*-\nfrom flask import Flask\nfrom playhouse.postgres_ext import PostgresqlExtDatabase\n\ndb = PostgresqlExtDatabase(None)\n\n\ndef create_app():\n app = Flask('calc')\n app.config[\"DEBUG\"] = True\n db.init('demo')\n print db.execute_sql(\n \"\"\"SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';\"\"\"\n ).fetchall() # ok!\n from test_api import api\n\n app.register_blueprint(api, url_prefix='/api')\n return app\n\n\nif __name__ == '__main__':\n create_app().run()\n```\n\nThe second one\n\n```\n# test_api.py\n# -*- coding: utf-8 -*-\nfrom flask import Blueprint, jsonify\nfrom test import db\n\napi = Blueprint('api', __name__)\n\n\[email protected]('/log', methods=[\"GET\", \"POST\", \"PUT\", \"DELETE\", \"PATCH\", \"OPTIONS\"])\[email protected]_on_success\ndef logging_handler():\n return jsonify(hello='world from api')\n```\n\n**B. Does Work!**\n\nOne file\n\n```\n# test.py\n# -*- coding: utf-8 -*-\nfrom flask import Flask, Blueprint, jsonify\nfrom playhouse.postgres_ext import PostgresqlExtDatabase\n\ndb = PostgresqlExtDatabase(None)\napi = Blueprint('api', __name__)\n\n\[email protected]('/log', methods=[\"GET\", \"POST\", \"PUT\", \"DELETE\", \"PATCH\", \"OPTIONS\"])\[email protected]_on_success\ndef logging_handler():\n return jsonify(hello='world from api')\n\n\ndef create_app():\n app = Flask('calc')\n app.config[\"DEBUG\"] = True\n db.init('demo')\n print db.execute_sql(\n \"\"\"SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';\"\"\"\n ).fetchall() # ok!\n\n app.register_blueprint(api, url_prefix='/api')\n return app\n\n\nif __name__ == '__main__':\n create_app().run()\n```\n", "this does not work either (with 2 files):\n\n```\[email protected]('/log', methods=[\"GET\", \"POST\", \"PUT\", \"DELETE\", \"PATCH\", \"OPTIONS\"])\ndef logging_handler():\n with db.transaction():\n return jsonify(hello='world from api')\n```\n", ".. and this:\n\n```\n# -*- coding: utf-8 -*-\nfrom flask import Blueprint, jsonify\nimport test\ndb = test.db\n\napi = Blueprint('api', __name__)\n\n\[email protected]('/log', methods=[\"GET\", \"POST\", \"PUT\", \"DELETE\", \"PATCH\", \"OPTIONS\"])\[email protected]_on_success\ndef logging_handler():\n return jsonify(hello='world from api')\n```\n", "The only way I found to fix that is:\n\n```\ndef create_app():\n app = Flask('calc')\n app.config[\"DEBUG\"] = True\n from test_api import api, db\n db.init('demo')\n print db.execute_sql(\n \"\"\"SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';\"\"\"\n ).fetchall() # ok!\n\n app.register_blueprint(api, url_prefix='/api')\n return app\n```\n\nBut this does not looks like a solution because there could be more than 1 file which imports db from skeleton.\n", "But! If I split app skeleton into 2 files:\n\n```\n# -*- coding: utf-8 -*-\nfrom playhouse.postgres_ext import PostgresqlExtDatabase\n\ndb = PostgresqlExtDatabase(None)\n```\n\nand\n\n```\n# -*- coding: utf-8 -*-\nfrom flask import Flask\n\n\ndef create_app():\n app = Flask('calc')\n app.config[\"DEBUG\"] = True\n from test import db\n db.init('demo')\n from test_api import api\n\n print db.execute_sql(\n \"\"\"SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';\"\"\"\n ).fetchall() # ok!\n\n app.register_blueprint(api, url_prefix='/api')\n return app\n\n\nif __name__ == '__main__':\n create_app().run()\n```\n\nthen it works.\n\nI really don't understand this ...\n", "I made a very simple example which is working fine for me locally:\n\n``` python\n### app.py\nfrom peewee import *\n\ndb = SqliteDatabase(None)\n\ndef initialize():\n db.init(':memory:')\n```\n\n``` python\n### db.py\nfrom peewee import *\nfrom app import db\n\nclass User(Model):\n username = CharField()\n class Meta:\n database = db\n\[email protected]_on_success\ndef test_fn(username):\n User.create(username=username)\n```\n\n``` python\n### main.py -- use python main.py to run\nfrom app import *\nfrom db import *\n\ninitialize()\nUser.create_table()\ntest_fn('asdf')\n```\n\nIt works as expected and the `id()` of the database is consistent. Throughout (verified using interactive debugger).\n", "I'm going to close this as I don't believe there is a peewee bug here.\n" ]

[]

[]

[ "I can see how that code appears confusing. The `only` parameter accepts a list of fields, and `model_instance.dirty_fields` returns a list of fields that have been modified. Using the two together, you can accomplish \"save only the fields that changed\":\n\n``` python\nproject.save(only=project.dirty_fields)\n```\n", "Please let me know if this does not address your concern.\n", "Yes, It solves the problem. I just thought the presence of a composite primary key were not a good criteria to save all fields or just the dirt ones.\n", "Looking at d53415fb, I think that code is there to replace previous logic that popped the PK off the field dict when updating a model.\n" ]

[]

[]

[ "> It would make a big trouble if the keyword is the typo.\n\nYes, that's a valid point.\n\n> Charfield would accept all kinds of types other than basestring\n> BooleanField would accept all kinds of types other than Boolean\n\nThe `python_value` and `db_value` functions on field ensure that the correct types are passed when reading rows from the database, and vice-versa.\n", "Is it valuable to add in a keyword validation in case of typo as sqlalchemy?\n", "A `KeyError` will be raised if you try to insert data into a non-existant field, though this happens at execution time rather than the time the insert is instantiated. I think this is sufficient and will leave the logic as-is.\n", "But if birthday is optional field and when try to insert, a birthdays typo happened, this field would be ignored, but it should not be!\n\nI can't find the keyerror in this case. \n", "https://github.com/coleifer/peewee/blob/706c9d8e67f22f8610142dcaf2e37829f3f9d138/peewee.py#L2556-L2582\n\nParticularly 2560.\n", "The code in my example would work in peewee, and would not give keyerror at all.\nThis keyerror will check the insert keyword? \n" ]

[]

[]

[ "After looking at how the `save()` method is implemented, it looks like it can't tell the difference between this:\n\n```\npage = Page.get(Page.url == 'http://example.com')\n```\n\nand this:\n\n```\npage = Page(url='http://example.com')\n```\n\ni.e. between a persisted object and one that exists only in Python.\n\nAnyway, my workaround was to add an extra `if` and use `Page.create()`.\n\nI'll leave this open in case it's deemed worth fixing.\n", "As the documentation states, when using a non-auto-incrementing primary key, you must call `save()` on new instances by passing `force_insert=True`.\n\nhttp://docs.peewee-orm.com/en/latest/peewee/models.html#non-integer-primary-keys-composite-keys-and-other-tricks\n" ]

[]

[]

[]

[]

[]

[ "I noticed an indentation error in the minimal example above: `return DynamicTable` is indented one level to deep.\n\nI must confess that I have not read the peewee source in detail. But could it be, that even after the deletion of `dyntable`, the class `StaticTable` still has some sort of reference to it?\n", "I was able to make it work by defining destructors on the ForeingKeyField and the BaseModel classes:\nhttps://github.com/hitzg/peewee/commit/3cb1feb4f477d540d6ff1ad951c04304eee176a7 \nI did not define a new test, but all the old ones seem to run ok. I can create a pull request, but I'm not sure if my solution is safe / not introducing other problems.\n\nEDIT: haha, I haven't seen your commit.... sorry\n", "Actually I think I made the indentation error when copying the code from StackOverflow.\n\nEven after the deleteion of `dyntable`, yes, `Statictable` will retain a back-reference. Maybe I need to find a way to hook into the deletion of a Model class from memory.\n", "Ah, you added `__del__` to the model metaclass, perfect! I wlil definitely take your changes, they look great.\n", "Actually quick question -- in your code on `BaseModel.__del__` your override accepts the `self` argument, yet it accesses `cls` inside. I'm curious how this worked, since I would think that would be a `NameError`.\n", "Sorry, I really was too quick on that. you are quite right, using `cls` raises a `NameError`. Not sure what I have tested before, but somehow I tricked myself.\nI figured out two things:\n1. The approach works (at least with these corrections: https://github.com/hitzg/peewee/commit/f6cafe05ecbd43b48b9acf23c4f4ad400e00c72d), as far as I can tell (Its +3000 lines of code and I haven't spent a lot of time looking at it ;)\n2. The destructors need to be called explicitly (in the minimal example above you have to call do `dyntable.__del__()`, which means that somewhere there are further references to the objects. I'm not sure where though. So it might make more sense to put the code in some sort of `release_backrefs` function.\n", "> The destructors need to be called explicitly (in the minimal example above you have to call do `dyntable.__del__()`, which means that somewhere there are further references to the objects. I'm not sure where though. So it might make more sense to put the code in some sort of release_backrefs function.\n\nAhh, that makes sense. I was testing locally and there were still references hanging around. Even calling `del SomeClass` did not work. I started a SO thread which has more details: http://stackoverflow.com/questions/27018721/python-del-method-for-classes\n", "At this point I will have to use the fix you provided. Thank you for all the help!\nOne more question: Is there a downside / performance loss related to setting `validate_backrefs = True`?\n", "Not really, just that you may overwrite a pre-existing backref or attribute. In your case I think it should be fine.\n" ]

[]

[]

[ "Thanks for sharing this. I'm sorry that you've still been experiencing errors.\n\nQuick question -- are you calling `my_db.connect()` and `my_db.close()` between requests? I ask because these calls are necessary for opening the conn and for returning it to the pool.\n\nI think some improvements could definitely be made to the mysql pool implementation -- particularly now that there's an API hook for determining if a connection is actually available.\n", "Ha! That might just be it. I wasn't aware I have to manually open/close the connections, but that seems only logical now that I think of it >.<\n\nRelated to that, I'm using the Thrift TForkedServer, which forks a new process for each request. Will the pool with threadlocals=True work fine with this?\n", "And also, what will happen if too many requests come in at once and the number of max_connections is reached? I'd like them to wait until a new connection is available, and not to fail.\n", "> Related to that, I'm using the Thrift TForkedServer, which forks a new process for each request. Will the pool with threadlocals=True work fine with this?\n\nAhh... I am not sure how that will work. The connections will be opened and maintained in the server process, then when `fork` is called they will be used in the request process... But I'm not sure what will actually happen there. If it spawned a thread for each request then `threadlocals` would work, but I'm not sure for an entire process.\n\n> And also, what will happen if too many requests come in at once and the number of max_connections is reached? I'd like them to wait until a new connection is available, and not to fail.\n\nCurrently the pool does not block, though this might be worth adding. You could always subclass and override the pool's `_connect()` method, then call it in a busy-loop?\n", "Thanks man! I'll experiment with this and report back on how it goes.\n", "Cool, I'll look into it as well this evening when I'm done with work.\n", "Where are you at with this one? Did connect/close per-request fix the issue?\n", "So I tinkered around a lot and changed a bunch of things, and it does seem to be more stable. Especially the \"MySQL server gone away\" error hasn't appeared since, and just logically I don't think it will. I haven't seen the \"Connection lost during query\" one yet, but if it happens again I guess I should also have a look at the MySQL server configuration.\n\nAs for the ForkedServer, I found out that the different forks do not share the memory for variables, which means the Pool essentially becomes useless. Thus it would be a feasible solution to combine the ForkedServer with just opening a simple connection per fork. I guess I can load test that at some point, but for now I'm going for ThreadedServer with Connection Pool.\n\nFor establishing connections, I added the busy loop as you suggested to make sure queries only fail if the server is really busy.\n\nThanks!\n", "Hmm so when posting a lot of parallel requests to my server, at some point one query and all subsequent will fail with the OperationalError: (2013, \"Lost connection to MySQL server during query (timeout('timed out',))\"). Sadly, Peewee seems unable to restart the connection then, and I have to manually restart the whole service in order for it to work again... Do you have an idea how I can have the Pool automatically kill connections that have died like this? At this point I'm not even sure the Thread/Pool combination is doing what I want. I have each request run on a separate thread, and each thread opens/closes connections from the Pool.\n", "I guess I could subclass Database and have execute_sql catch OperationalErrors and automatically reconnect if that happens? Could that cause any other issues? Would I lose my transactions?\n", "> As for the ForkedServer, I found out that the different forks do not share the memory for variables, which means the Pool essentially becomes useless.\n\nCorrect -- at this point you are going to be opening a connection-per-process.\n\n> Thus it would be a feasible solution to combine the ForkedServer with just opening a simple connection per fork. I guess I can load test that at some point, but for now I'm going for ThreadedServer with Connection Pool.\n\nThat sounds good. Make sure you are instantiating your database with `threadlocals=True` (this is the default but in older versions of peewee this was not the case).\n\n> For establishing connections, I added the busy loop as you suggested to make sure queries only fail if the server is really busy.\n\nHave you tested your implementation? Can you share any code?\n\n> Hmm so when posting a lot of parallel requests to my server, at some point one query and all subsequent will fail with the OperationalError: (2013, \"Lost connection to MySQL server during query (timeout('timed out',))\").\n\nIf you can, I'd like to see as much of your relevant code as you can share. Or perhaps an example that illustrates the problem. I'm having a hard time connecting this behavior with the implementation of the pool.\n\n> I guess I could subclass Database and have execute_sql catch OperationalErrors and automatically reconnect if that happens? Could that cause any other issues? Would I lose my transactions?\n\nI would advise against that.\n", "Sure let me see how much code I can share. However, I did not subclass the Pool as proposed, but rather just wrapped the connect calls. Maybe I'll do that now that it has proven to be useful. This is all very hacky and probably not pythonic, but here goes:\n\n```\ndef connect_to_db_with_retries(db, tries=50, pause=0.05):\n for t in xrange(tries):\n try:\n db.connect()\n return\n except ValueError:\n # no connection in pool\n if t + 1 == tries:\n raise\n time.sleep(pause)\n```\n\nThen, I have a wrapper around each handler method (each of those should be called in a subthread) that goes something like this:\n\n```\ndef connect(db):\n def connect_decorator(f):\n @wraps(f)\n def wrapper(*args, **kwargs):\n connect_to_db_with_retries(db)\n\n try:\n result = f(*args, **kwargs)\n except OperationalError:\n db.manual_close()\n\n db.close()\n\n return result\n return wrapper\n return connect_decorator\n```\n\nOh and here is how I instantiate the pool:\n\n```\ndb = PooledMySQLDatabase(charset='utf8', use_unicode=True, max_connections=1000, connect_timeout=10, stale_timeout=60, **db_credentials)\n```\n\nNote that it's actually slightly more complicated than this, since I have separate read/write connections. If you think this could be part of the issue, I can add the relevant code. Oh and the Thrift Threaded Server implementation can be found here:\nhttps://github.com/evernote/evernote-sdk-python/blob/master/lib/thrift/server/TServer.py#L92\n\nThanks again!\n", "For an example that illustrates the problem: I built a little Go-tool that sends random requests in parallel to my Python service. Here is a little table to illustrate the scale (which makes it seem like the MySQL requests are actually handled consecutively):\n\n```\nn parallel requests | avg time for request (s) | n errors\n1 | 0.1 | 0\n2 | 0.2 | 0\n4 | 0.4 | 0\n8 | 0.8 | 0\n16 | 1.6 | 0\n32 | 3.2 | 0\n64 | - | 64\n```\n\nNote that this wall where all the requests fail and return \"Connection lost during query\" is reached whenever the average time reaches the connection_timeout I set when initializing the pool (in this case it was 5). This raises two concerns for me:\na) Why is the time scaling exponentially with number of parallel requests? By the way, average here means that ALL of the requests basically need exactly that amount of time, even the very first one which shouldn't face any obstacles\nb) Why do all the connections break and need to be manually closed if this happens?\n", "It looks to me like the time is not scaling exponentially but linearly, and that might indicate that your parallel requests are running sequentially. I'm not sure what's going on -- I have very littleexperience with MySQL (I use SQLite/Postgres), so I have no idea what the db server might be doing. My best suggestion is just to add a shitload of logging and try to go from there. If you had some minimal code that reliably reproduced this problem, I'd be happy to dig further.\n", "Yeah you're right, the time per request scales linearly, but that makes the whole process explode. I'll go with your advice and log the shit out of it :) Thanks man!\n", "I've got more info! Hopefully this will help us both. So I ran my server and sent four parallel requests its way. I enabled the Pool's logging, as well as some logging by me: 1. When a request is received. 2. When we are done handling it, along with the time it took 3. Inside pool.py whenever _close or _connect are called. The results are as follows (with some comments)\n\n```\nRequest received\nConnect call:\nNo connection available in pool.\nRequest received\nConnect call:\nNo connection available in pool.\nRequest received\nConnect call:\nNo connection available in pool.\nRequest received\nConnect call:\nNo connection available in pool.\n# Up until here, no connections were available, so four connections should have been created right?\nCreated new connection 4335533392.\nCreated new connection 4335533392.\nCreated new connection 4335533392.\nCreated new connection 4335533392.\n# Wrong! They all have the same key... If that means that only one connection was opened or if they just all get mapped to the same key, I don't know\n# And now see how these are handled in a linear fashion, but each thread seems to think it \"owns\" the connection with this key\nClose call:\nReturning 4335533392 to pool.\nRequest finished: Took 2.06 sec\nClose call:\nReturning 4335533392 to pool.\nRequest finished: Took 2.14 sec\nClose call:\nReturning 4335533392 to pool.\nClose call:\nRequest finished: Took 2.15 sec\nReturning 4335533392 to pool.\nRequest finished: Took 2.16 sec\n```\n\nThis could have many implications and I will wait for your comments. But yeah apparently I'm doing something wrong or the pool is not very smart when too many new connections come at once (and there aren't enough connections in the pool). At least this explains why it seemed like my requests are sequential and not parallel. Note that the base 2 seconds is probably the time it needed to connect to the DB, as I'm behind a VPN at the moment.\n\nThanks,\nMax\n", "That certainly is strange, I think some weird things must be going on but I'm not sure what.\n\nThe key used for the connection is `id()` which should be the memory address of the database connection. If you created your `MySQLDatabase` with `threadlocals=True`, then technically a connection should be opened for each thread. I would guess this was the case, but it seems like something else is going on. What does your code look like that opens each connection? What does your database definition look like? I'm also curious what your server looks like. Anything I can implement on my end to try and replicate your setup will be good. Thanks for your help with this, I'll spend some more time looking into the unit-tests.\n", "Weird...\n\nWell, my server is pretty complicated, but the main parts are as described above:\n- Basis for my threaded server is TThreadedServer, which is provided by Thrift and should be stable and trustworthy. The logs above should also show that each request is indeed launched in it's own thread, since they handle the requests in parallel.\n- I have separate read and write connections (and for each maintain one pool), but open/close only what is needed for the request. In this case, I only need read connections so all the above applies to the read pool.\n- Each handler method (aka method ran in it's own thread) is wrapped as I explained above so that it first opens the connections it needs (here only read), then handles the request, and then closes them. In case an OperationalError occurs, I call close_manual() on the connection so it doesn't get recycled.\n- The DB is defined roughly as follows:\n \n ```\n write_database = Proxy()\n read_database = Proxy()\n \n class BaseModel(gfk.Model, read_slave.ReadSlaveModel):\n class Meta:\n database = write_database\n read_slaves = (read_database,)\n \n def __str__(self):\n return str(self.__dict__['_data'])\n \n # Model definitions etc...\n \n def initialize_db_proxy(db_credentials):\n \"\"\" Init the models with the given databases. \"\"\"\n \n write_db = PooledMySQLDatabase(charset='utf8', use_unicode=True, max_connections=1000, connect_timeout=10, stale_timeout=60, threadlocals=True, **db_credentials['write'])\n \n # Only initialize read-connection if given in config\n read_db = None\n if \"read\" in db_credentials:\n read_db = PooledMySQLDatabase(charset='utf8', use_unicode=True, max_connections=1000, connect_timeout=10, stale_timeout=60, threadlocals=True, **db_credentials['read'])\n \n write_database.initialize(write_db)\n read_database.initialize(read_db or write_db)\n ```\n\nAre there any other values I can log to help debug this?\n", "I wrote a little test script which, in my mind, shows that the pool works correctly. The idea is the program will spawn 10 threads. Each thread adds a row to the database which indicates:\n- the thread ID (each thread should have a unique id)\n- the available connections (should be empty)\n- the connections in use (should grow with each thread)\n- a piece of data unique to the thread\n\nWhen all threads are done, the program prints the number of rows in the database and the number of connections in use by the pool.\n\n``` python\nimport threading\n\nfrom peewee import *\nfrom playhouse.pool import PooledPostgresqlDatabase\n\n\ndb = PooledPostgresqlDatabase('peewee_test')\n\nclass Note(Model):\n data = TextField()\n\n class Meta:\n database = db\n\nNote.drop_table(True)\nNote.create_table()\n\nclass NoteThread(threading.Thread):\n def __init__(self, data, *args, **kwargs):\n self.data = data\n super(NoteThread, self).__init__(*args, **kwargs)\n\n def run(self):\n db.connect()\n values = [\n 'Thread ID=%s' % self.ident,\n 'Pool connections=%s' % db._connections,\n 'Pool in use=%s' % db._in_use,\n 'Data=%s' % self.data,\n ]\n Note.create(data='\\n'.join(values))\n\nthreads = [NoteThread(str(i)) for i in range(10)]\nfor t in threads:\n t.start()\nfor t in threads:\n t.join()\n\nprint 'Connections\\n=============='\nprint db._connections\nprint 'In use\\n====='\nprint len(set(db._in_use))\nprint\nprint 'Notes in database: %s' % Note.select().count()\n```\n\nOutput:\n\n```\nConnections\n==============\n[]\nIn use\n=====\n10\n\nNotes in database: 10\n```\n", "D'oh! Of course something fishy was going on... While experimenting I must have at some point switched back to TForkedServer, so all my \"threads\" were actually processes. I switched back to threads and now the behavior is at it should be!\n\nThanks a lot for your example. I notice that you don't close the connections after you're done, but that is probably for educational purposes. Trying to log these two values (db._connections and db._in_use) is what led me ultimately to debug the thread creation.\n\nAnd overall, thanks for your amazing and quick help! Peewee is awesome and I'll definitely recommend it to my friends!\n", "> I notice that you don't close the connections after you're done, but that is probably for educational purposes\n\nYes, that was just to show that there are multiple connections in use.\n\n> And overall, thanks for your amazing and quick help\n\nMy pleasure glad to help. Thanks for working with me on this issue.\n", "Hi \nI have a question that I prefer to ask here because it's relevant.\n\nwhy do we need to start/close connections? In the connectionloop case, what does that really mean? Isn't the pool responsible for taking care of connections (closing idle ones and connecting once a connection is needed)?\n", "When a connection is opened the pool will check to see if it's stale, and if so, will close it and reopen a new one, but there is no \"active\" monitoring of the connections.\n", "I have same problem：... (2006, \"MySQL server has gone away (error(32, 'Broken pipe'))\")\nanyone have a solution? tks.\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", "Awesome! Thanks\n", "Hi, \r\nI have some questions. This is my error:\r\n\r\nI used PooledMySQLDatabase . And I used the 'with db.atomic()' to process request, so I think connect will return back to pool. \r\nI think the reason for this is that MySQL closed automatic the connection, but peewee doesn't know. From the Docs, I couldn't find any about automatic-reconnect. I know RetryOperationalError can deal with, but I find it had delete from shortcuts file. I don't know why. Is there other method I don't find?\r\nWhat should I do? Thanks\r\n\r\n", "MySQL will close connections after a certain period of time. When using the connection pool, you'll want to make sure the [\"stale_timeout\"](http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#PooledDatabase) is set to some value less than mysql server's timeout.\r\n\r\nAdditionally, if you're using the connection pool, you need to explicitly connect and close connections, just as if you were using the regular/non-pooled connection type. This gives peewee an opportunity to recycle/close the connection as appropriate. It sounds like you may not be doing this, though. Read the docs: http://docs.peewee-orm.com/en/latest/peewee/database.html#connection-management", "Just a quick Q&A: does `connection_context()` closes the connection properly using a pooled connection? Or do I need to close it manually as well?\r\n\r\nThe [docs](http://docs.peewee-orm.com/en/3.6.0/peewee/api.html#Database.connection_context) say:\r\n>Create a context-manager that will hold open a connection for the duration of the wrapped block.\r\n\r\nBut omits if I need to close the connection.\r\n\r\nExample:\r\n```\r\ndef run():\r\n with db.connection_context():\r\n with db.atomic() as txn:\r\n # do stuff\r\n```", "Ignore my previous comment, looking at the source code of `ConnectionContext`, it's pretty clear that it opens and closes the connection. I will leave both of my comments for documentation purposes.\r\n\r\nIt would be nice if this is explicitly stated in the docs! :)\r\n\r\n```\r\nclass ConnectionContext(_callable_context_manager):\r\n __slots__ = ('db',)\r\n def __init__(self, db): self.db = db\r\n def __enter__(self):\r\n if self.db.is_closed():\r\n self.db.connect()\r\n def __exit__(self, exc_type, exc_val, exc_tb): self.db.close()\r\n```" ]

[]

[]

[ "The insert ID is returned on a `Model.save`. `Database.last_insert_id` takes a cursor _which was used to insert a row_ and returns the ID of the inserted row. By calling `Database.get_cursor`, your asking Peewee to open a _new_ database cursor, which will have no previously executed queries attached to it, and thus it cannot return a last-insert-id. Because this is a mostly undefined behavior, different error cases will happen for each DB-adapter.\n", "@b1naryth1ef is correct, you would need to use the cursor you executed the `INSERT` with. If you are executing an `INSERT` statement, it will return the last row id automatically, and that can give you some insight into how to do it:\n\n``` python\n def execute(self):\n if self._is_multi_row_insert and self._query is None:\n if not self.database.insert_many:\n last_id = None\n for row in self._rows:\n last_id = InsertQuery(self.model_class, row).execute()\n return last_id\n return self.database.last_insert_id(self._execute(), self.model_class)\n```\n" ]

[]

[]

[ "Thank you for this issue, looking into it now.\n" ]

[]

[]

[ "I tried a raw SQL query and it works fine:\n\n``` SQL\nSELECT * FROM image JOIN treatment WHERE image.date == treatment.date\n```\n\nThe database backend is SQLite.\n", "Have you tried explicitly setting the join condition?\n\n``` python\npredicate = (Image.date == Treatment.date) & (Image.time == Treatment.time)\n query = Image.select().join(\n Treatment,\n on=predicate)\n```\n", "That works by setting the join condition. I thought I could set it using where, but that's not the right place.\n\nThanks!\n" ]

[]

[]

[ "Thank you, but I will pass on this in order to keep the example simple.\n" ]

[]

[]

[ "Thanks for the suggestion. I think I'm going to pass on this, but if you would like to submit a pull-request with an implementation, I'd help review it.\n" ]

[]

[]

[]

[]

[]

[]

[]

[]

[ "Your query is incorrect.\n\n``` python\n(User\n .select(User, fn.COUNT(Tweet.id).alias('count'))\n .join(Tweet)\n .group_by(User)\n .having(fn.COUNT(Tweet.id) > 0))\n```\n", "When aggregating, you can only filter on aggregates in the `HAVING` clause. Additionally, you need to tell the database how to group the rows -- in this case, by user.\n", "My bad, I thought I had filtered by SUM or COUNT in a WHERE clause in MySQL before.. but maybe that was an erroneous recollection. thanks for the help!\n" ]

[]

[]

[ "You might try:\n\n``` python\nfn.EXTRACT(Clause(SQL('EPOCH FROM'), SomeModel.field))\n\n# or\n(fn.EXTRACT(Clause(SQL('EPOCH FROM'), SomeModel.field)) * 1000).alias('session_id)\n```\n", "For future reference it looks like you want to use `NodeList` now instead of Clause", "This is built-in to the database object as of Peewee 3. You can use `db.extract_date('epoch', M.field)`." ]