Datasets:

---

akumoth

/

peewee-issues

like 0

[]

[]

[ "I do not think that I would merge such functionality into peewee, but if you end up implementing it on you r own I'd love to see the diff. Maybe you could post it to this issue?\n", "Haven't implemented yet, but I'm imagining this. This is not using the signals architecture as I'm not too well-read on your implementation of it.\n\n```\n# Save method on the base model (from which everyone inherits)\ndef save(self, *args, **kwargs):\n # Check all our ForeignKeyFields...\n for field in self.dirty_fields():\n if isinstance(field, ForeignKeyField):\n # If we're using signals, I think we would look it up and fire it here instead of making a\n # heavy assumption that the rel_model implements the method fk_established(self)\n try:\n field.rel_model.fk_established()\n except AttributeError:\n pass\n```\n" ]

[]

[]

[ "Thank you!\n" ]

[]

[]

[]

[]

[]

[ "Well, technically I think you can specify those using PRAGMAs, can't you? Or as manual params with `connect()`...\n\nBut isn't the `uri` aspect fairly new to pysqlite, or am I mistaken?\n", "It looks also like it's a Python3 only thing at the moment, added in 3.4, so I'm going to hold off on supporting that directly.\n", "Oh I wasn't aware of PRAGMAs, I'll take another look at this, thanks!\n", "After looking at this deeper, some options cannot be enabled via PRAGMAs, such as \"shared cache\". In this particular example, Python 2.x would have to use `sqlite3.enable_shared_cache(True)` module global, rather than specifying in the URLs. For this feature to have Python 2.x support, the `uri` module functionality would have to be [backported](https://hg.python.org/cpython/rev/f13bb1e40fbc), which is extremely difficult given that it's a `cpython` module. \n\nFor anyone seeing this in future, if you're using Python 2.x then you're mostly outta luck. If you're using Python 3.x, then use `uri=True`.\n" ]

[]

[]

[ "If you're using SQLite, then while Peewee supports RIGHT OUTER, SQLite itself does not. Can you simply switch the order of your joins and use a left outer?\n", "You may need to add clauses to your where or join as well that allow for the date to be NULL. But, basically this is a SQL question not a peewee bug.\n" ]

[]

[]

[ "Peewee does not alter the isolation level of the postgres connection, unfortunately the `autocommit` parameter is poorly named. When True, it means basically: \"pass queries through the DB-API driver normally and call connection.commit() afterwards\". If False, then you need to call commit() yourself.\n\nWorking with the psycopg2 connection seems like the best route, since you need to set the connection's isolation level. I think psycopg2 issues an implicit `BEGIN` when you are not in autocommit mode, so that may be what's causing the trouble.\n", "For now I think it will suffice to leave the `autocommit` semantics as they are. There's quite a bit that's confusing given that postgres itself specifies AUTOCOMMIT differently than the DB-API 2.0, and peewee having it's own definition certainly adds to the confusion.\n\nThe code you have there looks good to me, so I'm going to close this.\n" ]

[]

[]

[ "Good question, no I hadn't thought about a corollary to the many-to-many add, but that seems useful. I will add it.\n", "Well, I forgot that the reverse fk descriptor exposes a plain old select query. It seems smelly to me to special case the select query returned by the fk descriptor. Similarly, I don't know that I like the idea to expose a wrapper / subclass with an `add()` method.\n\nSo, at the moment, I will say that there is no such method, but that you can do something like:\n\n``` python\ndef add_child(parent, child):\n child.parent = parent.id\n child.save()\n```\n\nOr, generically:\n\n``` python\ndef add_general(source, reverse_rel, child_inst):\n # source = \"father\", reverse_rel = \"father.children\"\n # reverse_rel.field.to_field.name = \"id\"\n target_val = getattr(source, reverse_rel.field.to_field.name)\n setattr(inst, reverse_field.field.name, target_val)\n inst.save()\n```\n", "Thanks for the response. I ended up with something like this to determine the complimentary relation name.\n\n```\nfather._meta.reverse_rel['children'].name\n```\n\nWhich correctly returns `parent` in this context. But your response has me questioning the use of reverse_rel for this purpose. Any issues there?\n", "That's totally fine as well.\n" ]

[]

[]

[ "Unfortunately not right now, though that's a deficiency in the API I've definitely thought about before. I will think about improving it.\n", "Ok!\n\nI've done some fix, if someone else have this requirement, maybe they can use this as a temporary solution. ^_^\n\n``` python\nimport peewee\nfrom peewee import PrefetchResult, Query, Model, prefetch\n\ndef _prefetch_add_subquery(sq, subqueries):\n fixed_queries = [PrefetchResult(sq)]\n for i, subquery in enumerate(subqueries):\n # === custom ===\n if isinstance(subquery, tuple):\n subquery, target_model = subquery\n else:\n target_model = None\n # === /custom ===\n\n if not isinstance(subquery, Query) and issubclass(subquery, Model):\n subquery = subquery.select()\n subquery_model = subquery.model_class\n fkf = backref = None\n if target_model is None: # custom\n for j in reversed(range(i + 1)):\n last_query = fixed_queries[j][0]\n last_model = last_query.model_class\n foreign_key = subquery_model._meta.rel_for_model(last_model)\n if foreign_key:\n fkf = getattr(subquery_model, foreign_key.name)\n to_field = getattr(last_model, foreign_key.to_field.name)\n else:\n backref = last_model._meta.rel_for_model(subquery_model)\n\n if fkf or backref:\n break\n else:\n # === custom ===\n last_query = first(fixed_queries, lambda q: q.model == target_model).query\n foreign_key = subquery_model._meta.rel_for_model(target_model)\n fkf = getattr(subquery_model, foreign_key.name)\n to_field = getattr(target_model, foreign_key.to_field.name)\n # === /custom ===\n\n if not (fkf or backref):\n raise AttributeError('Error: unable to find foreign key for '\n 'query: %s' % subquery)\n\n if fkf:\n inner_query = last_query.select(to_field)\n fixed_queries.append(\n PrefetchResult(subquery.where(fkf << inner_query), fkf, False))\n elif backref:\n q = subquery.where(backref.to_field << last_query.select(backref))\n fixed_queries.append(PrefetchResult(q, backref, True))\n\n return fixed_queries\n\ndef first(seq, condition):\n for value in seq:\n if condition(value):\n return value\n return None\n\npeewee.prefetch_add_subquery = _prefetch_add_subquery\n```\n\nUsage:\n\n```\nprefetch(School, SchoolClass, Club, (Student, School))\n```\n" ]

[]

[]

[ "The fix does not work. The `elif` branch is never reached because the timedelta object evaluates to `True`, so the behavior is the same as before.\n" ]

[]

[]

[ "Wontfix\n" ]

[]

[]

[ "Can you provide more information? What database are you using? What is actually failing? You've shown the delete call, but not the select portion.\n\nI added a test-case and it is passing, so I'm confused what might be going wrong:\n\n``` diff\n\n+\n+ def test_atomic_with_delete(self):\n+ for i in range(3):\n+ User.create(username='u%s' % i)\n+\n+ with test_db.atomic():\n+ User.get(User.username == 'u1').delete_instance()\n+\n+ usernames = [u.username for u in User.select()]\n+ self.assertEqual(sorted(usernames), ['u0', 'u2'])\n```\n\nIf you have a query object, perform a delete/update, then re-iterate the query then yes, you will get cached results. Simply call `query.clone()` in that case to blow away the result cache.\n", "I use mysql, flask and PooledMySQLDatabase.\n\nDatabase Connection\n\n```\nPooledMySQLDatabase(database,**{\n \"passwd\": password, \"user\": user,\n \"max_connections\":None,\"stale_timeout\":None,\n \"threadlocals\" : True\n })\n```\n\nDeleting\n\n```\nclass DeleteController(OAuthApiController, BaseMethodView):\n\n def __init__(self):\n super(DeleteController, self).__init__()\n\n def get(self,id):\n data = {\"error\" : \"no\", \"message\" : g._(\"Deleting tweet from twitter takes a long time\")}\n\n from flask import copy_current_request_context\n @async\n @copy_current_request_context\n def deleteFromTwitter(oAuthItemReply):\n app.preprocess_request()\n time.sleep(random.randint(60,80))\n try:\n try:\n tweepyOauth = tweepy.OAuthHandler(app.config[\"TWITTER\"][\"consumer_key\"], app.config[\"TWITTER\"][\"consumer_secret\"])\n tweepyOauth.set_access_token(oAuthItemReply.send_oauth_account.oauth_token, oAuthItemReply.send_oauth_account.oauth_token_secret)\n twitterApi = tweepy.API(tweepyOauth,parser=tweepy.parsers.JSONParser())\n a = twitterApi.destroy_status(oAuthItemReply.send_item.oauth_item_id)\n print \"deleted >> \" + str(oAuthItemReply.send_item.oauth_item_id)\n except tweepy.error.TweepError, e:\n oauthError = e.message\n print oauthError\n\n with g.db.connection.atomic() as txn:\n oAuthItemReply.delete_instance()\n except Exception, e:\n print e\n\n try:\n g.db.disconnect()\n except Exception, e:\n print e\n\n return \"ok\"\n\n try:\n with g.db.connection.atomic() as txn:\n RepliedOAuthItemAlias = OAuthItem.alias()\n SendOAuthItemAlias = OAuthItem.alias()\n oAuthItemReply = (OAuthItemReply\n .select(OAuthItemReply,RepliedOAuthItemAlias,SendOAuthItemAlias,OAuthAccount,User)\n .join(RepliedOAuthItemAlias,on=(OAuthItemReply.replied_item==RepliedOAuthItemAlias.id) )\n .switch(OAuthItemReply)\n .join(SendOAuthItemAlias,on=(OAuthItemReply.send_item==SendOAuthItemAlias.id) )\n .switch(OAuthItemReply)\n .join(OAuthAccount)\n .switch(OAuthItemReply)\n .join(User) .where(OAuthItemReply.organization==g.auth.getOrganizationId())\n .where(OAuthItemReply.id==id)\n .get()\n )\n oAuthItemReply.send_status_id = OAuthItemSendStatusEnum.DELETING.value\n oAuthItemReply.save(only=oAuthItemReply.dirty_fields)\n\n # call thread\n deleteFromTwitter(oAuthItemReply)\n\n data[\"oauth_item_reply\"] = model_to_dict(oAuthItemReply, exclude = [OAuthItemReply.reply_thread, OAuthItemReply.organization, User.password],recurse = True) \n except Exception, e:\n data[\"error\"] = \"yes\"\n data[\"message\"] = g._(\"An error occured\")\n print e\n return self.response(data)\n```\n\nSelecting\n\n```\nclass ItemsTwitterController(OAuthApiController, BaseMethodView):\n\n def __init__(self):\n super(ItemsTwitterController, self).__init__()\n\n def get(self):\n data = {\"error\" : \"no\", \"message\" : None, \"take\" : request.args.get(\"take\",10), \"skip\" : request.args.get(\"skip\",0) }\n\n RepliedOAuthItemAlias = OAuthItem.alias()\n SendOAuthItemAlias = OAuthItem.alias()\n oAuthItemsReplies = (OAuthItemReply \n .select(OAuthItemReply,RepliedOAuthItemAlias,SendOAuthItemAlias,OAuthAccount,User)\n .join(RepliedOAuthItemAlias,on=(OAuthItemReply.replied_item==RepliedOAuthItemAlias.id) )\n .switch(OAuthItemReply)\n .join(SendOAuthItemAlias,on=(OAuthItemReply.send_item==SendOAuthItemAlias.id) )\n .switch(OAuthItemReply)\n .join(OAuthAccount)\n .switch(OAuthItemReply)\n .join(User)\n .where(OAuthItemReply.organization==g.auth.getOrganizationId())\n .limit(data[\"take\"])\n .offset(data[\"skip\"])\n )\n\n a = list()\n for item in oAuthItemsReplies:\n a.append(model_to_dict(item, exclude = [OAuthItemReply.reply_thread, OAuthItemReply.organization, User.password],recurse = True))\n data[\"oauth_reply_items\"] = a\n\n\n return self.response(data)\n```\n", "Can you send minimal example?\nOn Sep 5, 2015 10:58 AM, \"serkandaglioglu\" [email protected] wrote:\n\n> I use mysql, flask and PooledMySQLDatabase.\n> \n> Database Connection\n> \n> PooledMySQLDatabase(database,**{\n> \"passwd\": password, \"user\": user,\n> \"max_connections\":None,\"stale_timeout\":None,\n> \"threadlocals\" : True\n> })\n> \n> Deleting\n> \n> class DeleteController(OAuthApiController, BaseMethodView):\n> \n> ```\n> def __init__(self):\n> super(DeleteController, self).__init__()\n> \n> def get(self,id):\n> data = {\"error\" : \"no\", \"message\" : g._(\"Deleting tweet from twitter takes a long time\")}\n> \n> from flask import copy_current_request_context\n> @async\n> @copy_current_request_context\n> def deleteFromTwitter(oAuthItemReply):\n> app.preprocess_request()\n> time.sleep(random.randint(60,80))\n> try:\n> try:\n> tweepyOauth = tweepy.OAuthHandler(app.config[\"TWITTER\"][\"consumer_key\"], app.config[\"TWITTER\"][\"consumer_secret\"])\n> tweepyOauth.set_access_token(oAuthItemReply.send_oauth_account.oauth_token, oAuthItemReply.send_oauth_account.oauth_token_secret)\n> twitterApi = tweepy.API(tweepyOauth,parser=tweepy.parsers.JSONParser())\n> a = twitterApi.destroy_status(oAuthItemReply.send_item.oauth_item_id)\n> print \"deleted >> \" + str(oAuthItemReply.send_item.oauth_item_id)\n> except tweepy.error.TweepError, e:\n> oauthError = e.message\n> print oauthError\n> \n> with g.db.connection.atomic() as txn:\n> oAuthItemReply.delete_instance()\n> except Exception, e:\n> print e\n> \n> try:\n> g.db.disconnect()\n> except Exception, e:\n> print e\n> \n> return \"ok\"\n> \n> try:\n> with g.db.connection.atomic() as txn:\n> RepliedOAuthItemAlias = OAuthItem.alias()\n> SendOAuthItemAlias = OAuthItem.alias()\n> oAuthItemReply = (OAuthItemReply\n> .select(OAuthItemReply,RepliedOAuthItemAlias,SendOAuthItemAlias,OAuthAccount,User)\n> .join(RepliedOAuthItemAlias,on=(OAuthItemReply.replied_item==RepliedOAuthItemAlias.id) )\n> .switch(OAuthItemReply)\n> .join(SendOAuthItemAlias,on=(OAuthItemReply.send_item==SendOAuthItemAlias.id) )\n> .switch(OAuthItemReply)\n> .join(OAuthAccount)\n> .switch(OAuthItemReply)\n> .join(User) .where(OAuthItemReply.organization==g.auth.getOrganizationId())\n> .where(OAuthItemReply.id==id)\n> .get()\n> )\n> oAuthItemReply.send_status_id = OAuthItemSendStatusEnum.DELETING.value\n> oAuthItemReply.save(only=oAuthItemReply.dirty_fields)\n> \n> # call thread\n> deleteFromTwitter(oAuthItemReply)\n> \n> data[\"oauth_item_reply\"] = model_to_dict(oAuthItemReply, exclude = [OAuthItemReply.reply_thread, OAuthItemReply.organization, User.password],recurse = True)\n> except Exception, e:\n> data[\"error\"] = \"yes\"\n> data[\"message\"] = g._(\"An error occured\")\n> print e\n> return self.response(data)\n> ```\n> \n> Selecting\n> \n> class ItemsTwitterController(OAuthApiController, BaseMethodView):\n> \n> ```\n> def __init__(self):\n> super(ItemsTwitterController, self).__init__()\n> \n> def get(self):\n> data = {\"error\" : \"no\", \"message\" : None, \"take\" : request.args.get(\"take\",10), \"skip\" : request.args.get(\"skip\",0) }\n> \n> RepliedOAuthItemAlias = OAuthItem.alias()\n> SendOAuthItemAlias = OAuthItem.alias()\n> oAuthItemsReplies = (OAuthItemReply\n> .select(OAuthItemReply,RepliedOAuthItemAlias,SendOAuthItemAlias,OAuthAccount,User)\n> .join(RepliedOAuthItemAlias,on=(OAuthItemReply.replied_item==RepliedOAuthItemAlias.id) )\n> .switch(OAuthItemReply)\n> .join(SendOAuthItemAlias,on=(OAuthItemReply.send_item==SendOAuthItemAlias.id) )\n> .switch(OAuthItemReply)\n> .join(OAuthAccount)\n> .switch(OAuthItemReply)\n> .join(User)\n> .where(OAuthItemReply.organization==g.auth.getOrganizationId())\n> .limit(data[\"take\"])\n> .offset(data[\"skip\"])\n> )\n> \n> a = list()\n> for item in oAuthItemsReplies:\n> a.append(model_to_dict(item, exclude = [OAuthItemReply.reply_thread, OAuthItemReply.organization, User.password],recurse = True))\n> data[\"oauth_reply_items\"] = a\n> \n> \n> return self.response(data)\n> ```\n> \n> —\n> Reply to this email directly or view it on GitHub\n> https://github.com/coleifer/peewee/issues/704#issuecomment-137970652.\n", "@coleifer Ok I am coding a minimal example and after finish I will send example url\n", "I did a lot of tests and finally found the my mistake. \n\nIn my database class there is this code\n\n```\ndb.set_autocommit(False)\n```\n\nI changed and the problem is solved.\n\n```\ndb.set_autocommit(True)\n```\n\nBut when I set db.set_autocommit(False), this error exists only when I use thread. You can see the usage above.\n\n```\ndef async(f):\n def wrapper(*args, **kwargs):\n thr = Thread(target=f, args=args, kwargs=kwargs)\n thr.start()\n return wrapper\n\nfrom flask import copy_current_request_context\n@async\n@copy_current_request_context\ndef deleteFromTwitter(oAuthItemReply):\n ...\n```\n", "This appears not to be an issue with peewee, but with your usage. Consult the code and documentation.\n\nIn particular I'm not sure what exactly the nature of the issue is with your code. If you want to take the time to explain it very clearly and simply I might be able to offer guidance.\n", "Thank you for your offer I fixed for now, it seems there is no problem.\n" ]

[]

[]

[ "Yes this is a known (and obvious) limitation. You'll want to look into triggers.\n", "Not looking to resurrect the dead here, but could there perhaps be a docs update to reflect this? It says:\n\n> Provides an additional keyword argument created, indicating whether the model is being saved for the first time or updated.\n\nwhich to me made me expect it would work, and thus chase my tail until I came here. :)\n\nThanks!\n", "See 590ccac3044e13988270017b85ec85dd76161c8b\n", "Thanks!\n" ]

[]

[]

[ "Is database the flask peewee wrapper? Have you tried database.database in that case?\n", "Awesome! That was indeed the problem!\n\nThanks a million. Both for solving this, and for creating Peewee. We're already using it in several websites now. Big thumbs up!\n" ]

[]

[]

[ "Relevant https://github.com/coleifer/peewee/issues/689#issuecomment-133063492\n", "> - Add two new methods on Model called get_read_db() and get_write_db(). Both of which return cls._meta.database by default, ensuring backwards compatibility\n> - Modify anywhere which uses cls._meta.database to use these methods instead (e.g. select() uses get_read_db() and create_or_get() uses get_write_db() etc).\n\nGood ideas, I will put this together.\n", "Well, as I was getting into this, it looks to me like `get_read_database()` will be called a bit. I noticed in the \"read slave\" tests that the actual read-slave used was not predictable. This is because there may be multiple calls to `get_read_database()` over the course of a select query, each one of which performs the 'round robin' logic in the ReadSlaveModel. Having the calls isolated to the query classes was a way to work around this, but had other issues as you mentioned.\n\nI'm not positive where this will end up, but I do agree it could be better.\n", "I don't think this should be handled at the model level. This is a database adapter concern. In our case, we patched the `SelectQuery._execute()` to overcome this issue.\n\nAs I said previously, all our problems are related to the way connections are handled right now (and specifically because we're trying to keep them in a state per model). I think we should all take a fresh look at this and come up with a better API to handle all the use-cases.\n", "> I don't think this should be handled at the model level. This is a database adapter concern.\n\n@stas, the more I was looking at what the changes would look like, the more I agree with you. Specifically, the scope of the chosen db should be a transaction, in my mind.\n", "@coleifer I would be happy to help with the postgres parts. Including the read replicas support. I could draft something so you can take a look, just let me know.\n", "After consideration (and several reply rewrites!), I would agree that the query database persistency should probably be via a transaction, as this is more explicit. Am I correct in saying that `get_read_database/get_write_database` on the model are still required? \n\nAlso happy to assist with testing/review.\n", "Just for what its worth,you can use `Using` to specify a database to use\nfor a list of models, optionally within a transaction.\n\nScroll down a bit:\n\nhttp://peewee.readthedocs.org/en/latest/peewee/database.html#using-multiple-databases\nOn Sep 14, 2015 5:35 AM, \"Cal Leeming\" [email protected] wrote:\n\n> After consideration (and several reply rewrites!), I would agree that the\n> query database persistency should probably be via a transaction, as this is\n> more explicit. Am I correct in saying that\n> get_read_database/get_write_database on the model are still required?\n> \n> Also happy to assist with testing/review.\n> \n> —\n> Reply to this email directly or view it on GitHub\n> https://github.com/coleifer/peewee/issues/701#issuecomment-140031569.\n", "> @stas, the more I was looking at what the changes would look like, the more I agree with you. Specifically, the scope of the chosen db should be a transaction, in my mind.\n\nI can add another finding which should be taken into consideration while moving db out of model level.\nImagine you use server side cursor on one model and operate related one:\n\n``` python\nfrom playhouse import postgres_ext\n\nfor user in postgres_ext.ServerSide(User.select()):\n user.do_something_on_related_model(user.posts)\n user.number_of_posts = x\n user.save() \n```\n\nPeewee will not be able to save changes to user instance as User's db is occupied by server side iteration and any changes to User model are \"postponed\" until for loop is actually finished.\n", "That's another good point @alexanderad, and one I had not considered.\n", "> Peewee will not be able to save changes to user instance as User's db is occupied by server side iteration and any changes to User model are \"postponed\" until for loop is actually finished.\n\nThe reason they are postponed may be because `ServerSide` runs in a transaction. I don't see anywhere in the code (been a while since I wrote it) that would modify the db itself for server-side cursors.\n", "@stas -- have you tried the `Using` helper?\n", "@coleifer nope, in our context we are working with a bunch of models for read-replicas. `Using` would just complicate things. We ended up patching and handling database routing around `SelectQuery._execute`. It sort of works, but it is still a pain because of the way pool handles the connections.\n", "Not sure there's anything actionable here. Closing.\n", "@coleifer From what I can see, the original proposal for `get_read_database` and `get_write_database` are still both outstanding and valid, and was waiting on you to either accept or reject. The other comments don't seem to give a clear conclusion, could you give your thoughts/findings please?\n\nPS) Fwiw, I'm still willing to invest time into submitting a PR based on my original post\n", "@foxx is right. The problems with the way peewee handles connection management is still a major headache.\n", "Well, to my thinking, I figured that the `Using` context manager took care of most issues ([see docs](http://peewee.readthedocs.org/en/latest/peewee/api.html#Using)).\n\nYou could build higher-level APIs on top of it if that was your preference.\n\nRegarding connection management, again I'm not sure what to do here.\n", "@coleifer Ah okay, I'll have a try with `Using` and will update this issue if I run into any blockers. Thanks!\n" ]

[]

[]

[ "Cool, let's try it out!\n" ]

[]

[]

[ "Nice, thanks!\n" ]

[]

[]

[]

[]

[]

[ "You should be using `PrimaryKeyField` instead of `IntegerField`. The former is auto increment, while the latter is just an arbitrary int field.\n" ]

[]

[]

[ "In the current master branch there is a new param for `model_to_dict` called `extra_attrs`. You can use that parameter to indicate you want to include the `updater_id`:\n\n``` python\nmodel_to_dict(User, exclude=[User.updater], extra_attrs=['updater_id'])\n```\n", "@coleifer \nCould you add an argument for `model_to_dict` like include_only_sql_seleted_fields=False? If we send `include_only_sql_seleted_fields=True` the dict has only field which selected in sql query. \n\nFor example:\n\n```\nInserter = User.alias()\nuser = (User\n .select(User, Inserter )\n .join(Inserter, JOIN.LEFT_OUTER, on=(User.inserter==Inserter.user_id))\n .where(User.user_id=userId )\n .get()\n )\n\ndata[\"user\"] = model_to_dict(user, include_only_sql_seleted_fields=True)\n```\n\nThe output will be like this : \n\n```\n{\n \"user_id\" : 1,\n \"full_name\" : \"Test\",\n \"email\" : \"[email protected]\",\n \"user_status_id\" : 1,\n \"activation_key\" : None,\n \"mobile\" : \"0555\",\n \"insert_date\" : datetime,\n \"update_date\" : datetime,\n \"updater_id\" : 2,\n \"inserter\" : {\n \"user_id\" : 2,\n \"full_name\" : \"Test 2\",\n \"email\" : \"[email protected]\",\n \"user_status_id\" : 1,\n \"activation_key\" : None,\n \"mobile\" : \"05553\",\n \"insert_date\" : datetime,\n \"update_date\" : datetime,\n \"updater_id\" : 2,\n \"inserter_id\" : 5\n }\n}\n```\n", "Well, I'd need the actual query in that case so I could know which fields were selected. Something like:\n\n``` python\nmodel_to_dict(user, fields_from_query=query)\n```\n", "Don't you keep the query in model object(user) ?\n", "Added `fields_from_query` a93b6268a77039856d0c8ea70e5ded9996c00719.\n\n> Don't you keep the query in model object(user) ?\n\nNo.\n", "@coleifer Thanks.\n" ]

[]

[]

[ "Thank you, this should be fixed.\n" ]

[]

[]

[ "Why not just add a `pre_save` signal handler that sets an additional attribute on the class:\n\n``` python\n@pre_save(sender=SomeModel)\ndef pre_save_handler(sender, instance, created):\n instance._dirty_field_cache = instance.dirty_fields\n\n@post_save(sender=SomeModel)\ndef post_save_handler(sender, instance, created):\n # do something with instance._dirty_field_cache\n pass\n```\n" ]

[]

[]

[ "Figure out a way myself. Sample codes:\n\n``` python\nimport logging\n\nfrom playhouse.pool import PooledMySQLDatabase\nfrom peewee import OperationalError\n\n\nlogger = logging.getLogger(__name__)\n\n\nclass RetryPooledMySQLDatabase(PooledMySQLDatabase):\n\n def sql_error_handler(self, exception, sql, params, require_commit):\n if isinstance(exception, OperationalError):\n self.close()\n self.connect()\n return True\n\n def execute_sql(self, sql, params=None, require_commit=True):\n retry_times = 0\n max_retry_times = 3\n while True:\n try:\n return super(RetryPooledMySQLDatabase, self).execute_sql(\n sql, params, require_commit\n )\n except OperationalError:\n if retry_times >= max_retry_times:\n logger.warning(\n 'Maximum retry times(%s) exceeded, give up retrying.',\n max_retry_times,\n )\n raise\n\n retry_times += 1\n logger.warning(\n 'Executing SQL(%s), params(%s) error, retrying %s/%s time',\n sql,\n params,\n retry_times,\n max_retry_times,\n )\n```\n" ]

[]

[]

[ "If you add an alias to the second join specifying which attribute to use, peewee will do the right thing:\n\n``` python\nOpponent = User.alias()\nquery = (GameResult\n .select(GameResult, User, Opponent)\n .join(User, on=(GameResult.user == User.id))\n .switch(GameResult)\n .join(Opponent, on=(GameResult.opponent == Opponent.id).alias('opponent'))\n .order_by(Game.id))\n```\n\nI think peewee has enough info here, though, to perhaps determine that the `opponent` field is what we want. I will look into a fix.\n", "I've added some changes to the join logic and this should now be a bit smarter about assigning the joined instance to the correct attribute without requiring an explicit alias.\n", "Hey Charles, I'm just trying this out with the latest copy of master and doesn't seem to be working for me, have you pushed the commit or am I doing something wrong?\n\n```\nclass User(Model):\n uuid = UUIDField(primary_key=True)\n name = CharField()\n\nclass Brief(Model):\n uuid = UUIDField(primary_key=True)\n user = ForeignKeyField(User, null=False)\n assignee = ForeignKeyField(User, null=True)\n ...\n\nAssignee = User.alias()\nquery = Brief.select(Brief, User, Assignee)\n .join(User, on=(User.uuid == Brief.user))\n .switch(Brief)\n .join(Assignee, on=(Assignee.uuid == Brief.assignee).alias(\"assignee\"))\n .order_by(...)\n```\n\nIt's not applying the node alias properly by the looks of it because I get:\n\n```\nSELECT\n \"t1\".\"uuid\", \"t1\".\"user_id\", \"t1\".\"state\", \"t1\".\"sent\", \"t1\".\"assignee_id\",\n \"t2\".\"uuid\", \"t2\".\"name\",\n \"t3\".\"uuid\", \"t3\".\"name\"\n\nFROM \"brief\" AS t1\n INNER JOIN \"user\" AS t2 ON (\"t2\".\"uuid\" = \"t1\".\"user_id\")\n INNER JOIN \"user\" AS t2 ON (\"t3\".\"uuid\" = \"t1\".\"assignee_id\")\n\nORDER BY \"t1\".\"sent\", \"t1\".\"created\"\n```\n\nIt correctly applies it inside the node but not to the table alias, I therefore get.\n\n```\nProgrammingError: table name \"t2\" specified more than once\n```\n\nSorry for reopening a closed issue, let me know if you want a separate issue.\n", "Using your code I get the right SQL:\n\n``` python\nfrom peewee import *\n\ndb = SqliteDatabase(':memory:')\n\nclass User(Model):\n uuid = CharField(primary_key=True)\n name = CharField()\n\n class Meta:\n database = db\n\nclass Brief(Model):\n uuid = CharField(primary_key=True)\n user = ForeignKeyField(User)\n assignee = ForeignKeyField(User, null=True, related_name='_xxx')\n\n class Meta:\n database = db\n\ndb.create_tables([User, Brief])\n\nAssignee = User.alias()\nquery = (Brief\n .select(Brief, User, Assignee)\n .join(User, on=(User.uuid == Brief.user))\n .switch(Brief)\n .join(Assignee, on=(Assignee.uuid == Brief.assignee).alias('assignee'))\n .order_by(User.name))\nprint query\n```\n\nResult:\n\n``` sql\nSELECT \"t1\".\"uuid\", \"t1\".\"user_id\", \"t1\".\"assignee_id\", \"t2\".\"uuid\", \"t2\".\"name\", \"t3\".\"uuid\", \"t3\".\"name\" \nFROM \"brief\" AS t1 \nINNER JOIN \"user\" AS t2 ON (\"t2\".\"uuid\" = \"t1\".\"user_id\") \nINNER JOIN \"user\" AS t3 ON (\"t3\".\"uuid\" = \"t1\".\"assignee_id\") \nORDER BY \"t2\".\"name\"\n```\n\nWhat am I missing?\n", "I'm experiencing a similar issue. (also sorry for posting in old issue).\n\nI've written a script to demonstrate. If not a bug , hopefully can demonstrate\n\nEDIT - updating to remove a join\n\n```\nfrom __future__ import division\nfrom peewee import Model, JOIN_LEFT_OUTER\nfrom playhouse.shortcuts import model_to_dict\nfrom peewee import fn, SQL, JOIN\nfrom peewee import CharField, DateTimeField, BigIntegerField, BooleanField, IntegerField, ForeignKeyField, Proxy, TextField, PrimaryKeyField,DoubleField\nfrom playhouse.postgres_ext import PostgresqlExtDatabase\nfrom playhouse.postgres_ext import BinaryJSONField, ArrayField, TSVectorField\n\n\ndef dbfactory(dbname=\"hai\"):\n # https://github.com/coleifer/peewee/issues/410\n host = \"/tmp/\"\n user = \"hendler\"\n # user = \"root\"\n password = \"rootroot\"\n # max_connections = 350\n # stale_timeout = 3000\n # connection = PooledMySQLDatabase(dbname, host=host, user=user, passwd=password, charset='utf8', use_unicode=True, max_connections=max_connections, stale_timeout=stale_timeout )\n connection = PostgresqlExtDatabase(dbname, host=host, user=user, password=password, autocommit=True, autorollback=True)\n # connection.connect()\n return connection\n\n\nclass BaseModel(Model):\n \"\"\"Simple table with prevs and an integer.\"\"\"\n\n class Meta:\n \"\"\"Standard meta field.\"\"\"\n\n database = dbfactory()\n\n\n# https://github.com/coleifer/peewee/issues/692\n\n\nclass User(BaseModel):\n id = PrimaryKeyField()\n\n\nclass Question(BaseModel):\n id = PrimaryKeyField()\n\n\nclass Answer(BaseModel):\n id = PrimaryKeyField()\n user = ForeignKeyField(User, related_name='answerusers')\n question = ForeignKeyField(Question, related_name='answerquestions')\n\n\nclass Page(BaseModel):\n id = PrimaryKeyField()\n user = ForeignKeyField(User, related_name='pageusers')\n question = ForeignKeyField(Question, related_name='pagequestions')\n\n\nclass Comment(BaseModel):\n id = PrimaryKeyField()\n user = ForeignKeyField(User, related_name='commentusers')\n question = ForeignKeyField(Question, related_name='commentquestions')\n\n\ndef setup():\n print \"creating table\"\n print \"\\tuser -> 1:n -> pages -> 1:1 -> questions -> 1:n -> answers\"\n print \"\\tuser -> 1:n -> comments -> 1:1 -> questions -> 1:n -> answers\"\n # drop tables every time\n if Commment.table_exists():\n Commment.drop_table()\n if Page.table_exists():\n Page.drop_table()\n if Answer.table_exists():\n Answer.drop_table()\n if Question.table_exists():\n Question.drop_table()\n if User.table_exists():\n User.drop_table()\n\n User.create_table()\n Question.create_table()\n Answer.create_table()\n Page.create_table()\n Commment.create_table()\n\n user1 = User.create()\n user2 = User.create()\n\n question1 = Question.create()\n question2 = Question.create()\n question3 = Question.create()\n\n answer1 = Answer.create(question=question1, user=user1)\n answer2 = Answer.create(question=question2, user=user1)\n answer3 = Answer.create(question=question3, user=user1)\n answer4 = Answer.create(question=question3, user=user2)\n answer5 = Answer.create(question=question3, user=user2)\n\n page1 = Page.create(user=user1, question=question1)\n page2 = Page.create(user=user2, question=question3)\n comment1 = Comment.create(user=user2, question=question3)\n comment2 = Comment.create(user=user1, question=question2)\n\ndef runtest1():\n results = User.select(User, Page, Comment, Question, Answer)\n results = results.join(Page).join(Answer, on=(Answer.question_id == Page.question_id))\n results = results.switch(User).join(Comment).join(Answer, on=(Answer.question_id == Comment.question_id))\n print results.sql()\n for result in results:\n print result\n\ndef runtest2():\n # , on=(ActionTemplate.id == Action.actiontemplate)).alias('at')\n results = User.select(User, Page, Commment, Question, Answer)\n results = results.join(Page, on=(Page.user_id == User.id))\n results = results.join(Question, on=(Question.id ==Page.question_id).alias(\"page_question\"))\n results = results.join(Answer, on=(Answer.question_id == Page.question_id))\n results = results.switch(User)\n results = results.join(Comment, on=(Comment.user_id == User.id))\n results = results.join(Question, on=(Question.id == Comment.question_id).alias(\"comment_question\"))\n results = results.join(Answer, on=(Answer.question_id == Comment.question_id))\n\n print results.sql()\n for result in results:\n print result\n\nif __name__ == \"__main__\":\n import traceback\n setup()\n try:\n runtest1()\n except Exception as e:\n print e.message\n # print traceback.format_exc()\n try:\n runtest2()\n except Exception as e:\n print e.message\n # print traceback.format_exc()\n\n\n\n```\n\n The output\n\n```\ncreating table\n user -> 1:n -> pages -> 1:1 -> questions -> 1:n -> answers\n user -> 1:n -> comments -> 1:1 -> questions -> 1:n -> answers\nMissing required join predicate.\n('SELECT \"t1\".\"id\", \"t4\".\"id\", \"t4\".\"user_id\", \"t4\".\"question_id\", \"t5\".\"id\", \"t5\".\"user_id\", \"t5\".\"question_id\", \"t2\".\"id\", \"t3\".\"id\", \"t3\".\"user_id\", \"t3\".\"question_id\" FROM \"user\" AS t1 INNER JOIN \"page\" AS t4 ON (\"t1\".\"id\" IS %s) INNER JOIN \"comment\" AS t5 ON (\"t1\".\"id\" IS %s) INNER JOIN \"question\" AS t2 ON (\"t2\".\"id\" IS %s) INNER JOIN \"answer\" AS t3 ON (\"t2\".\"id\" = \"t3\".\"question_id\") INNER JOIN \"answer\" AS t3 ON (\"t2\".\"id\" = \"t3\".\"question_id\") INNER JOIN \"question\" AS t2 ON (\"t2\".\"id\" IS %s)', [None, None, None, None])\ntable name \"t3\" specified more than once\n```\n", "I don't get the error with aliasing, AND enforcing left outer joins. BUT the params values look off \n`[None, None, None, None]`\nWithout the left outer, the joins don't work. \n\n```\n AnswerAlias = Answer.alias()\n QuestionAlias = Question.alias()\n\n results = User.select(User, Page, Comment, Question, Answer, QuestionAlias, AnswerAlias)\n results = results.join(Page, JOIN.LEFT_OUTER, on=(Page.user_id == User.id))\n results = results.join(Question, JOIN.LEFT_OUTER, on=(Question.id == Page.question_id))\n results = results.join(Answer, JOIN.LEFT_OUTER, on=(Answer.question_id == Page.question_id))\n results = results.switch(User)\n results = results.join(Comment, JOIN.LEFT_OUTER, on=(Comment.user_id == User.id))\n results = results.join(QuestionAlias, JOIN.LEFT_OUTER, on=(QuestionAlias.id == Comment.question_id) )\n results = results.join(AnswerAlias, JOIN.LEFT_OUTER, on=(AnswerAlias.question_id == Comment.question_id))\n\n print results.sql()\n print results.count()\n\n```\n\n`('SELECT \"t1\".\"id\", \"t2\".\"id\", \"t2\".\"user_id\", \"t2\".\"question_id\", \"t3\".\"id\", \"t3\".\"user_id\", \"t3\".\"question_id\", \"t6\".\"id\", \"t7\".\"id\", \"t7\".\"user_id\", \"t7\".\"question_id\", \"t4\".\"id\", \"t5\".\"id\", \"t5\".\"user_id\", \"t5\".\"question_id\" FROM \"user\" AS t1 LEFT OUTER JOIN \"page\" AS t2 ON (\"t1\".\"id\" IS %s) LEFT OUTER JOIN \"comment\" AS t3 ON (\"t1\".\"id\" IS %s) LEFT OUTER JOIN \"question\" AS t4 ON (\"t4\".\"id\" IS %s) LEFT OUTER JOIN \"answer\" AS t5 ON (\"t4\".\"id\" = \"t5\".\"question_id\") LEFT OUTER JOIN \"question\" AS t6 ON (\"t6\".\"id\" IS %s) LEFT OUTER JOIN \"answer\" AS t7 ON (\"t6\".\"id\" = \"t7\".\"question_id\")', [None, None, None, None])`\n", "For fuck's sake did you have to put \"Bug\" in front of every class?\n" ]

[]

[]

[]

[]

[]

[ "Using an interactive debugger, are you able to examine the message of the warning that is failing to be displayed? My feeling is that this is not an issue with Peewee, but I'd like to be sure before closing.\n", "``` python\nfile.write(formatwarning(message, category, filename, lineno, line)\n```\n\nThat is the line that I think is problematic. Something in the warning message, maybe?\n", "warning is about having duplicate values I guess, that is why I used INSERT IGNORE. but anyway this throws an exception which should not happen.\nThe name of column I am using is unicode and somethimes it is ascii I guess...I am myself having problem printing it out....so I used two different lines of code to check if it is unicode or it is ascii!\n\nBut all subsequent enquires and everything works as far as I can tell! warning displaying causes problem\n", "> The name of column I am using is unicode and somethimes it is ascii I guess...I am myself having problem printing it out....so I used two different lines of code to check if it is unicode or it is ascii!\n\nOK, then that sounds like the issue. You might've mentioned that in the issue description. This isn't a peewee issue, but an issue with the MySQLdb library.\n" ]

[]

[]

[ "@stas -- what do you mean by read-only? You mean the `ReadSlaveModel` from `playhouse.read_slave`?\n\nCan you share some code so I can get a better idea of your configuration, as well as the problem you're experiencing?\n", "> @stas -- what do you mean by read-only? You mean the ReadSlaveModel from playhouse.read_slave?\n\nYes, sorry I forgot to mention the exact module.\n\n> Can you share some code so I can get a better idea of your configuration, as well as the problem you're experiencing?\n\nThere's nothing custom, we just extended our models with the `ReadSlaveModel` and we started getting `ValueError`s with: Exceeded maximum connections.\nI started tracking this down and it is generated by the `playhouse.pool._connect` which we use. Going deeper I discovered that the `max_connections` limit is reached because the connections are not returning back to the pool (aka closed). Honestly this makes sense since I couldn't find anywhere where those connections are managed to return back to pool/close.\n", "I'm assuming this is in a web app and that you've got some middleware or something opening connections (or checking them out) at the beginning of the request/response cycle, and closing them (returning them) at the end...\n\nIf that's the case, perhaps it would be sufficient in the \"close\" code (when you're done with a request) to iterate through all databases and do something like:\n\n``` python\ndatabases = [master] + read_slaves\nfor database in databases:\n if database.is_open():\n database.close()\n```\n", "> I'm assuming this is in a web app and that you've got some middleware or something opening connections (or checking them out) at the beginning of the request/response cycle, and closing them (returning them) at the end...\n\nNope, this is a heavily threaded application.\n\n> If that's the case, perhaps it would be sufficient in the \"close\" code (when you're done with a request) to iterate through all databases and do something like:\n\nWe explored this approach, in fact we were using it until we started adding read-only servers. We found that closing of the database connections performs strange (you really need to be handling this in the same thread and so on...).\n\nLast couple of days I started reading the way database and pooled database classes work and I could not understand some of the aspects. One of the main question is related to the fact that we actually need to manually close all the connections. By looking at the database API, I can see that an implementation where the connections are automatically picked, used and closed/put back is possible, still you decided a manual approach is better. Can I ask you why?\n", "> We found that closing of the database connections performs strange (you really need to be handling this in the same thread and so on...).\n\nCan you explain that more? What database engine are you using?\n\nActually now that you describe that, I can see how that might arise... Thread1 opens connection, does work, puts it back in pool and goes away. Thread2 checks out connection, does work, puts it back in pool. Pool decides connection is stale, so it closes it...Perhaps that's what happened?\n\n> One of the main question is related to the fact that we actually need to manually close all the connections.\n\nThat is the case whether you use a pool or just a regular `Database` subclass. It's written all over the docs, but you need to open the conn when you want to start work, then close it when you're done. For web apps this happens typically in the request/response cycle.\n\nIf you're using a pool, the only difference is that the pool manages the connections for you. It's transparent to the application -- the `connect()` and `close()` APIs are the same.\n\n> By looking at the database API, I can see that an implementation where the connections are automatically picked, used and closed/put back is possible, still you decided a manual approach is better. Can I ask you why?\n\nIt's true that a connection will be automatically opened if you try to execute a query and no conn has been opened yet. This is for backwards compatibility and to reduce boilerplate when writing simple scripts. There is no way, as far as I know, to automatically close or \"put back\" connections.\n", "Just out of curiosity, what database are you using? And do you have any more info regarding the error your received when closing connections (the error about \"threads\")?\n", "Following the docs, we managed to manually close opened connections, so I'm closing this.\n\n> It's true that a connection will be automatically opened if you try to execute a query and no conn has been opened yet. This is for backwards compatibility and to reduce boilerplate when writing simple scripts. There is no way, as far as I know, to automatically close or \"put back\" connections.\n\nIn regards to the question about automatic management of the connections, after looking at the query classes, maybe it's worth exploring the approach where connections are handled inside context managers and are automatically open and closed after the query is done. I tried patching the `Query._execute()` but the way query wrappers handle results (lazily), it didn't work properly.\n\n> Just out of curiosity, what database are you using? And do you have any more info regarding the error your received when closing connections (the error about \"threads\")?\n\nWe're using an extended postgres adapter, and the problem with that is, especially in a threaded environment, is that having a similar to the request/response approach is not necessarily a common case. Every-time we need to make changes to connection management or integrate our peewee models, we need to find a way how we are going to handle the connections management. You can imagine it is pretty frustrating :(\n\nThere's a lot of complexity required to provide the current connection state (`thread.local` and the whole execution context stack), so I started asking myself if there's no better way to handle this. Previously I had experience with working with the psycopg2 modules, and there are a couple of things that might help with this (consider using psycopg2.pool and it's API for managing cursors). I'm seriously thinking to take a shot on making the database adapter use coroutines or at least leverage the `psycopg2.pool` API.\n\nThanks a lot for helping with answers.\n", "I am not sure about using a connection-per-query. If you wanted to be very granular you could do a connection per transaction, that is not too uncommon, and in fact peewee's [ExecutionContext](http://docs.peewee-orm.com/en/latest/peewee/database.html#advanced-connection-management) ([api](http://docs.peewee-orm.com/en/latest/peewee/api.html#ExecutionContext)) does just this.\n\nI've used huey in a multi-threaded, long-running script -- managing the connections wasn't too difficult since peewee stores a connection-per-thread by default.\n\nThe postgresql pool is implemented very similar to the peewee pool as far as I can tell. Peewee goes a step further and adds the concept of an expiration time, but other than that they are quite similar. Peewee simply abstracts away the pool implementation details from the Database API so apps can go on using `connect()` and `close()` without being aware the conns are being pooled.\n", "> I am not sure about using a connection-per-query. If you wanted to be very granular you could do a connection per transaction, that is not too uncommon, and in fact peewee's ExecutionContext (api) does just this.\n\nThe issue is a little bit more complex. I can't speak for other databases, but postgres adapter doesn't provide an API to tell if the connection is still open or closed (see psycopg/psycopg2#263). The approach with keeping a connection around in the hope it will stay alive by the time a thread is done using it will not work unless you set a very low `stale_timeout`, and it will still not guarantee if the connection is still alive.\n\nWe're having issues with this exact aspect of the psycopg2 and peewee in some long-running multi threaded application (I'm talking about weeks of run-time here, ideally we would like to have it running for months like that, but it doesn't) and using the Redshift database (a postgres flavor). If we lower the `stale_timeout`, it will pretty-much work as a connection-per-query set-up.\n\nIf we look at the bigger picture here, the situation with the read-write queries split across different servers is another case where this doesn't fit well in the current approach the connections are handled (we have some workers running for hours, it might be that the read-only queries are just happening 10% of the time, why keeping the connection around all the time?).\n\nWhat I'm trying to say, is that the current adapter (talking about postgres here) could use some improvements to handle the connections in a better way and, why not, auto-close them without having the users to figure out when a connection is stalled and when it should be closed.\n\n> The postgresql pool is implemented very similar to the peewee pool as far as I can tell. Peewee goes a step further and adds the concept of an expiration time, but other than that they are quite similar. Peewee simply abstracts away the pool implementation details from the Database API so apps can go on using connect() and close() without being aware the conns are being pooled.\n\nThat is why I wonder why it was not just extended in peewee. Btw, looking at the persistent connection pool from psycogp2, I can spot the similarities with the current peewee's pool. It is also deprecated now.\nhttp://initd.org/psycopg/docs/pool.html#psycopg2.pool.PersistentConnectionPool\n", "I'm pretty sure that `psycopg2` provides a `closed` boolean attribute on the `Connection` object:\n\nhttp://initd.org/psycopg/docs/connection.html#connection.closed\n\nThe peewee connection pool uses this attribute to check whether a connection is closed when the application checks it out. So the pool will:\n1. Check that the conn wasn't open more than `stale_timeout` seconds ago.\n2. Check that `conn.closed` is not True.\n3. Release the connection to your app\n\n> we have some workers running for hours, it might be that the read-only queries are just happening 10% of the time, why keeping the connection around all the time?\n\nThen could you use a pool for the writers and a simple `PostgresqlDatabase` for the readers?\n\nRegarding the psycopg2 pool, I actually did not look at it's code until you mentioned it, as I didn't know it existed...I guess there's only so many ways to implement a simple pool, haha.\n" ]

[]

[]

[ "Weird, thanks for reporting.\n", "Are you using an older version of peewee? I think the issue was that in older versions there was a bug where `in_()` took `*args` rather than a single list.\n\nThe bug was fixed in fcfd914f, part of the 2.5.1 release.\n", "Omitted the version in my initial report, sorry, I was using 2.4.5. I upgraded to 2.6.3 and the problem is gone. Thanks for the very quick response.\n" ]

[]

[]

[ "Cool, this is a nice start.\n", "This behavior was added in #753.\n" ]

[]

[]

[ "I think what you have in your first snippet is good.\n\n``` python\ninstance = Model.get(...)\n\n...\n\ninstance = instance.refresh()\n```\n\nThe `refresh()` method could be:\n\n``` python\ndef refresh(self):\n return type(self).get(self._pk_expr())\n```\n", "How about adding this to core? I too would find it useful is some cases.\n", "We are also using this snippet, although I personally would expect a `refresh` method (terminology-wise) to update the instance in place, instead of returning a fresh copy.\n", "I defer to @coleifer of course since I'm just a barely-familiar user of `peewee`, but here's my $0.02:\n\nI'd buy you a beer if you could get that to work cleanly -- it's not as trivial as it would seem given my experience trying to work it out on my end. It's one thing to set the data on the Model subclass object, but once you start considering things like dirty fields, object caches, etc., it starts unraveling.\n\n`thing = thing.refresh()` is really not that much more of a headache IMO. If that's losing any kind of locally-set data, my guess is you're probably Doing It Wrong™.\n\nMaybe it's a semantics issue then -- perhaps it'd be better off called `inflate()` or `regenerate()` or `evolve()` or `reincarnate()`... actually, I kind of like `reincarnate()`...\n", "If you want to get into a really hairy territory, you could go so far as to write some kind of code that takes in the remote updated version and _merges_ it with the local object, and if it's trying to clobber a locally-dirty field, raise some kind of exception, etc, but then again this is becoming more not-very-Pythonic the more we explore the possibilities.\n", "I think something like this should be nice, but I in fact just wrote it now and haven't yet tested enough. This works «in place» by loading another instance of the same class and copying all its fields. Seems to work as planned, but I am pretty sure there are some unwanted side effects somewhere. Maybe somebody has a better implementation?\n\n``` python\ndef reload(self):\n newer_self = self.get(self._meta.primary_key == self._get_pk_value())\n for field_name in self._meta.fields.keys():\n val = getattr(newer_self, field_name)\n setattr(self, field_name, val)\n self._dirty.clear()\n```\n" ]

[]

[]

[ "Don't know the framework, but you should probably use [middleware](https://pythonhosted.org/wheezy.http/userguide.html#middleware). Assuming `peewee_middleware` is never the last one:\n\n```\ndef peewee_middleware(request, following):\n db.connect()\n try:\n response = following(request)\n finally:\n if not db.is_closed():\n db.close()\nreturn response\n\napp = WSGIApplication(middleware=[\n lambda x: peewee_middleware,\n path_routing_middleware_factory\n])\n```\n\nI would think this question belongs more to wheezy.web project than to peewee, though.\n", "Thanks. I added this here because the peewee documentation specifically asks you to open a ticket if there are any other frameworks you'd like to see examples for. http://docs.peewee-orm.com/en/latest/peewee/database.html#other-frameworks\n", "Oh, I stand corrected. Did you have luck with the suggestion?\n", "@thirashima -- If you come up with some working code, please comment on this issue and I will add it to the docs. For now I am closing this.\n", "the code that tuukkamustonen provided does seem to be working. thank you everyone for the help.\n", "Cool, I will update the docs, thanks d00dz.\n", "http://docs.peewee-orm.com/en/latest/peewee/database.html#wheezy-web\n" ]

[]

[]

[ "Not at present, but I would consider a pull request and would work with you on getting the code into good shape. For now I'd suggest using hand-written SQL queries if you want upserts with MySQL.\n" ]

[]

[]

[ "At present Peewee uses the `bool` data-type, which is also what Django uses for BooleanField in Django.\n\nIf you want `Bit` specifically you can either create a custom field, or specify a field override:\n- http://docs.peewee-orm.com/en/latest/peewee/models.html#creating-a-custom-field\n- http://docs.peewee-orm.com/en/latest/peewee/api.html#Database\n", "Thank you very much! My problem was easily solved.\n\nI'm sorry I didn't read the docs more carefully. Perhaps a link to the section \"Creating a custom field\" directly after the field types table could prevent others from making the same mistake.\n", "Added the links, thanks!\n", "@jmenglund Hello, I am trying to do the same but I have troubles converting the string of hex characters retrieved to booleans. I am a beginner in Python, could you share some snippet" ]

[]

[]

[ "Here is a description of the problem:\n\n``` python\n# create 5 users, named user0-user4\nquery = User.select()\nfor o in query:\n print 'o ->', o.username\n for i in query:\n print ' i ->', i.username\n```\n\nThis will print:\n\n```\no -> u0\n i -> u0\n i -> u1\n i -> u2\n i -> u3\n i -> u4\n```\n", "So when you iterate over a `SelectQuery` it creates a `QueryResultWrapper` which allows for efficient iteration and indexing. The problem is that the iterator is stateful.\n\nThe workaround I'd suggest is just to coerce to a `list` beforehand. You can also call `QueryResultWrapper.fill_cache()`.\n\nI'll see about a better fix.\n", "This should now be fixed in master.\n", "Great, thanks!\n" ]

[]

[]

[ "Could probably tidy up the code a little, and we'll need sign off from @coleifer on the `query` conditional, but assuming those two things are signed off, then LGTM.\n", "@messense Has this already been merged into master?", "I don't know. I haven't used peewee for a long time and I think I won't be working on this so I closed it.", "@coleifer Any thoughts on whether you'd like this in master?", "No, get or create is evil. One of my biggest regrets" ]

[]

[]

[ "I don't really think this is a use-case I had intended to cover.\n" ]

[]

[]

[ "That's an interesting point and has to do with the implementation of the descriptor. When the value is set (you assign the `File()` obj), the file has no primary key so peewee records `None` as the related object ID. The fact that the `File` later gets an ID is not caught by the field.\n\nI think this warrants some investigation, thanks for bringing it up.\n" ]

[]

[]

[]

[]

[]

[ "wontfix\n" ]

[]

[]

[]

[]

[]

[ "This is to differentiate pre-fetched \"static\" results from the descriptor that exposes related objects as a `SelectQuery`.\n\nI do not plan on changing this, but you can modify your code:\n\n``` python\ndef format_messages(user):\n messages = getattr(user, 'messages_prefetch', user.messages)\n return [message.data for message in messages]\n```\n" ]

[]

[]

[ "Thanks for reporting, fixed in c1030f58c0df67b28fefa75182d6a93698921e01\n", "Thanks for fixing it so quickly. Cheers.\n" ]

[]

[]

[ "IIRC, the newer versions are throwing this error, because they default to having `STRICT_TRANS_TABLES` on.\n", "@jakedt -- I'm not quite sure I understand. What exactly is going on here?\n", "When we define a large column that is to be indexed, e.g.:\n\n``` python\nbig_col = CharField(index=True, max_length=1024)\n```\n\nand the version of MySQL defaults to `STRICT_TRANS_TABLES`, subsequent calls to `create_model_tables([ModelWithBigCol])` will cause MySQL to spit out the error from above. We can't change the size of the columns, but we can tell MySQL that we're ok with using a smaller prefix for the index.\n\nHere is an SO post talking about the issue: http://stackoverflow.com/questions/1814532/1071-specified-key-was-too-long-max-key-length-is-767-bytes\n", "Gotcha -- I think this is a wontfix from my point-of-view. The issue is an implementation detail of MySQL's storage engines, and I don't think Peewee has an opinion on that.\n", "Is there not something salvageable across DBMSs whereby we can specify the index prefix length though? This would be enough to allow us to work around the MySQL issues, and may prove helpful when other people are defining their indices with peewee, since they know what's best for their data model.\n", "I ran into this problem myself, and my (admittedly partial) workaround for it was a custom field type:\n\n```\nclass EnforcedCharField(CharField):\n def __init__(self, max_length=255, *args, **kwargs):\n self.max_length = max_length\n super(CharField, self).__init__(*args, **kwargs)\n\n def db_value(self, value):\n if value is None:\n length = 0\n else:\n try:\n length = len(str.encode(value))\n except TypeError:\n length = len(value)\n\n if length > ENFORCED_CHARFIELD_CONSTRAINT:\n from core.error import DatabaseError\n raise DatabaseError(\"The field '{}' cannot be longer than {} bytes. ({})\".format(\n self.name,\n ENFORCED_CHARFIELD_CONSTRAINT,\n request.url))\n return super(CharField, self).db_value(value) \n```\n\n(`ENFORCED_CHARFIELD_CONSTRAINT` is set elsewhere; in this cases it's 767.)\n\nI ran into this problem mainly because of fields where Unicode data was present.\n", "@jakedt -- what would you propose peewee do if a user defines a `CharField` with an index length exceeding what the storage engine supported? I don't think peewee should silently truncate the index -- instead it should raise an error. Well, MySQL is already raising the error for you, so in my mind there's nothing to do.\n", "The problem for me is that the column length and the index length are inextricably tied together. If I could add a keyword to my column definition, e.g. `index_prefix_length=128`, and if this worked across providers, that would increase the expressiveness of the peewee model definitions and let me work around my MySQL issue.\n\nRight now, facing this error, I have only one option, reduce the length of my column. If I can't do that because my data model requires a column of that length, I have zero options.\n", "@jakedt -- could you create the index by hand?\n\n``` python\nclass MyModel(Model):\n big_col = CharField(max_length=1024)\n\n @classmethod\n def create_table(cls, fail_silently=False):\n super(MyModel, cls).create_table(fail_silently=fail_silently)\n cls._meta.database.execute_sql('CREATE INDEX mymodel_big_col ON mymodel (big_col(255))\n```\n", "@coleifer What you just posted for @jakedt would actually solve my problem quite nicely from the look of it. I never liked the idea of enforcing length constraints for the sake of the underlying index, but I was also reluctant to pass explicit index creations (for the sake of maximum compatibility). Come to think of it, I might be able to set things up so that depending on what database is attached, the appropriate index-creation instructions are passed. (I don't think the example listed would have any ill effects when used in SQLite for instance, but I'd like to ensure it doesn't.)\n", "We can't do that because then our migration generator tool will assume that we don't want an index. We can extend that to read additional keywords and work around that too, but I think the idea of having a smaller index than the column length is more general than just working around problems. If we take a stab at modifying peewee to allow for specifying an index_length, would you consider merging it?\n\nI don't actually know how to extend the compound index syntax to allow for this yet.\n", "@jakedt -- so you are proposing silently shortening the index length in Peewee? I don't think it's the ORM's business to do that. As I said,\n\n> The issue is an implementation detail of MySQL's storage engines, and I don't think Peewee has an opinion on that.\n\nI feel like I've proposed a reasonable solution (create the index explicitly), and @syegulalp has proposed another reasonable solution (create a custom field). At this point I feel like you're just complaining.\n" ]

[]

[]

[ "This looks good, I'm sorry for not responding sooner, completely fell off my radar.\n\nI'd like to merge. Looks like the only issue is the lack of the unicode literal in the earlier python 3 build. If that can be fixed, I'd be happy to merge this.\n", "Nice! :)\n@coleifer any rough idea when this will be released? \n", "Hopefully the next week or so. Thank you!\nOn Nov 12, 2015 9:46 AM, \"Yohan Boniface\" [email protected] wrote:\n\n> Nice! :)\n> @coleifer https://github.com/coleifer any rough idea when this will get\n> released?\n> \n> —\n> Reply to this email directly or view it on GitHub\n> https://github.com/coleifer/peewee/pull/672#issuecomment-156142700.\n" ]

[]

[]

[ "This has nothing to do with Peewee as far as I can tell, but is an implementation detail of the `Enum` class.\n", "Okay, thanks.\n\nDo you have any suggestions for a more Pythonic solution than the (somewhat confusing) `@staticmethod` decorator, or am I just overthinking this? I'm still learning Python and want to establish good habits. :)\n", "Use @staticmethod.\n", "Thanks!\n\n## \n\nSent from my tin cans and a piece of string. \n\n> On Jul 27, 2015, at 9:34 AM, Charles Leifer [email protected] wrote:\n> \n> Use @staticmethod.\n> \n> ―\n> Reply to this email directly or view it on GitHub.\n" ]

[]

[]

[ "Thanks!\n" ]

[]

[]

[ "Here's my init code:\n\n```\nclass SqliteFKDatabase(SqliteDatabase): \n def initialize_connection(self, conn): \n self.execute_sql('PRAGMA foreign_keys=ON;`)\n```\n\n```\ndb = SqliteFKDatabase(None)\n\ndef init_db(DB): \n db.init(DB) \n\n init_db(TEST_SQL) \n```\n", "Well, your cursor for the outer `SELECT` statement is still open, so by consuming the outer `SELECT` you should get your code working:\n\n``` python\nfor i in range(1, nb_rows // CHUNK_SIZE + 2): \n rows = (Source.select(Source.name,Source.country) \n .where(Source.status == 'new').paginate(i, CHUNK_SIZE).tuples()) \n\n # CONSUME SELECT\n rows = list(rows)\n\n for name,country in rows: \n person, created = Person.create_or_get(name = name, new = True) \n\n if country: \n country, created = Countries.create_or_get(name = country) \n Person_Country(person_id = person.id, country_id = country.id).save() \n```\n\n`create_or_get` will use a transaction (or savepoint if you're already in a transaction). When this is committed or rolled back, the cursor for the `SELECT` can no longer be used.\n" ]

[]

[]

[ "I wouldn't say \"incorrectly\" -- Peewee does not have any field comparable to a case-insensitive text field. Pwiz is designed to cover the most common data-types but it cannot hope to cover them all. Hence, `UnknownField`. You can go through and replace them with `TextField` if you like.\n", "Aren't `text` and `citext` different, though? Isn't the real problem that peewee doesn't have a case-insensitive field?\n", "They are different, and yes, the issue is that peewee does not have a case-insensitive text field. That said, I don't plan on adding one. If you'd like you can add one yourself quite easily, though:\n\nhttp://docs.peewee-orm.com/en/latest/peewee/models.html#creating-a-custom-field\n", "Is it as simple as,\r\n\r\n class CITextField(TextField):\r\n field_type = 'citext'", "That's all you need." ]

[]

[]

[ "Where are you using sqlite3 been mentioned in your code example?\nOn Jul 22, 2015 11:08 PM, \"Daniel Mead\" [email protected] wrote:\n\n> I've just had a problem were i didn't have MySQLdb installed, so peewee\n> failed over to sqlite3\n> \n> this was really annoying because it happened silently and without warning.\n> \n> im using a statement like this to connect\n> \n> db = MySQLDatabase('somedatabase', host='127.0.0.1', port=3306,\n> user='user', passwd='pass')\n> \n> —\n> Reply to this email directly or view it on GitHub\n> https://github.com/coleifer/peewee/issues/667.\n", "thats the point. i'm not. peewee is defaulting to write to a file called \"peewee.db\" every time.\n", "Peewee will not do this silently. Can you share your model definitions? I'm wondering if you neglected to set the db for your models.\n", "``` python\nfrom myproject import database\n\nclass BaseModel(Model):\n class Meta:\n db = database\n```\n\ni'm also using arnold to run table creation stuff, if that matters to you\n", "Peewee raises an exception on not installing pymysql and MySQLdb! Which\nversion are you using?\nOn Jul 22, 2015 11:13 PM, \"Daniel Mead\" [email protected] wrote:\n\n> thats the point. i'm not. peewee is defaulting to write to a file called\n> \"peewee.db\" every time.\n> \n> —\n> Reply to this email directly or view it on GitHub\n> https://github.com/coleifer/peewee/issues/667#issuecomment-123822485.\n", "i have both installed. actually.\n", "Pay attention, is your code running correctly? Any old edition of code\ncached and run? Can you paste your file content and describe a little about\nyour process of run code?\nOn Jul 22, 2015 11:32 PM, \"Daniel Mead\" [email protected] wrote:\n\n> i have both installed. actually.\n> \n> —\n> Reply to this email directly or view it on GitHub\n> https://github.com/coleifer/peewee/issues/667#issuecomment-123828265.\n", "Yeah, basically this doesn't add up. Peewee won't silently \"fall back\" to SQLite if you're trying to use MySQL. And if you don't have a mysql driver installed and try to use MySQLDatabase, it will raise an error.\n", "my bad.\n\nthe ref i had inside the base model was bad. it was actually falling back to sqlite but it was my fault.\n" ]

[]

[]

[ "That line of code is there to allow you to quickly create models that point to a SQLite database named `peewee.db`. So if you just imported `Model` and did not define your own database, it would use the `default_database`.\n\nMost everyone will define their own db, though, so this is not an issue in practice, e.g.\n\n``` python\nfrom peewee import *\n\ndb = SqliteDatabase('my_database.db')\n\nclass BaseModel(Model):\n class Meta:\n database = db\n\n# application models extend `BaseModel`.\n```\n" ]

[]

[]

[ "Change:\n\n``` python\ninner_query = Log.select().order_by(Log.DateTimeUTC.desc()).limit(20)\n```\n\nTo:\n\n``` python\ninner_query = Log.select(Log).order_by(Log.DateTimeUTC.desc()).limit(20)\n```\n\nIf a subquery does not have an explicit selection, peewee assumes you just want the primary key, hence the missing column.\n" ]

[]

[]

[ "What database are you using? The code you've referenced is not relevant to your question as far as I understand what you're asking. The code you want is probably here:\n\nhttps://github.com/coleifer/peewee/blob/1b021602a222485d5f28857a363cd378dc874df0/peewee.py#L1050-L1068\n\nBasically, peewee will just pass the `datetime` object back to the database driver (psycopg2, sqlite3, pymysql, etc). From there, it's up to the database driver what to do with the Python `datetime` object. When Peewee reads the value _back_ from the database, some dbs (SQLite) may return it as a string, so there is logic to convert the string into a `datetime` object. As you can see in the `formats` list, peewee will attempt to parse out microseconds.\n", "Yeah, you're right. Though I still can't get it to work, so maybe i'm missing something.\n\nI'm using MySQL 5.7.\n\nAn example (mostly copied from the docs) is:\n\n```\nclass Person(Model):\n name = CharField()\n birthday = DateTimeField()\n\n class Meta:\n database = db\n\np = Person(name='Bob', birthday=datetime.datetime.now())\np.save()\n\nPerson.get(Person.name == 'Bob').birthday # output: datetime.datetime(2015, 7, 21, 14, 57, 26)\n```\n\nBut... looking at the SQL table directly shows that it isn't stored entirely (i.e. the value is stored as \"2015-07-21 14:57:26\"). So its a problem during storage, not retrieval. Note that the default fractional part for a `DATETIME` column in MySQL (>= 5.6.4) is 0 (https://dev.mysql.com/doc/refman/5.7/en/fractional-seconds.html).\n", "I'd suggest checking out your python driver, as Peewee really should just be passing back the `datetime` object directly to it.\n", "Aren't the drivers a part of peewee? Unless I misunderstand what you mean.\n", "No, pymysql and mysql-python, etc are separate packages.\n", "D'oh. Thanks, i'll look into those.\n", "FYI, the problem wasn't on PyMySQLs end.\n\nWhat happens is that the default `QueryCompiler` (https://github.com/coleifer/peewee/blob/master/peewee.py#L1350) datetime conversion results in columns being created as \"DATETIME\". But MySQL defaults fractional parts to 0 so any saves resulted in the datetime being truncated. The solution is to override the `field_map` when creating the `Database` instance: `db = MySQLDatabase(..., fields={'datetime': 'DATETIME(6)'})`. This forces all `DATETIME` columns to have fsp 6.\n", "You can create a custom field type or specify one or more `field_overrides` when instantiating your database.\n- http://docs.peewee-orm.com/en/latest/peewee/models.html#creating-a-custom-field\n- http://docs.peewee-orm.com/en/latest/peewee/api.html#Database\n", "After read the information you provided, I got this, and it seems work:\n\n```\ndatabase = MySQLDatabase(dbname, fields={'datetime_fsp6': 'DATETIME(6)'})\n```\n\n```\nclass DateTimeFsp6Field(DateTimeField):\n db_field = 'datetime_fsp6'\n```\n\n```\nclass FooModel(Model):\n ctime = DateTimeFsp6Field(default=datetime.datetime.now)\n```\n", "Thanks for sharing your solution @binderclip!\n", "Shouldn't @binderclip be the default for Mysql ?", "@luisulloa IIUC, not all MySql versions support this" ]

[]

[]

[ "Cool models bro, what's your question?\n", "Maybe `query.tuples()` or `query.dicts()` are exactly what you looking for?\n", "You want something like:\n\n``` python\nPost.select(Post.post_title, Post.post_content, User.username).join(User)\n```\n\nThen you can iterate through the results of the query and access `post.post_title`, `post.post_content`, and `post.user.username`.\n", "For future reference, questions like this belong on StackOverflow rather than the peewee bug tracker.\n", "When I used\n\n``` python\nquery = Post.select(Post.post_title, Post.post_content).join(Act).where(Act.id == actId).paginate(actPage, 15)\nquery_dataList = []\nfor query_line in query:\n query_data = model_to_dict(query_line)\n query_dataList.append(query_data) \n json_data = json.dumps(query_dataList)\n```\n\nthen converted it to json,I got this\n\n``` json\n[{\"post_views_count\": null, \"post_title\": \"\\u4e0d\\u9519\", \"post_comments_count\": null, \"post_likes_count\": null...\n```\n\nIt seems like the fields I didn't include in the \"select()\" return null,and I only want the selected fields.I'm not sure is't something wrong with my code or it is designed like this and I will ask in StackOverflow next time,Thanks.\n", "function `model_to_dict` serialises **all** fields from model (wholly). You should use `model_to_dict(query_line, only=(Post.post_title, Post.post_content))`.\n\nOr as I said before use `query.dicts()`\n", "Yes, you should read the documentation on `model_to_dict`: http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#model_to_dict\n\nIt will serialize everything unless you specify `only`, which in your case seems to be what you want.\n", "@klen @coleifer Thanks bro.\n" ]

[]

[]

[]

[]

[]

[ "Closing, because I realized that the underlying problem is with `get` and that trying to do a `get` on a derived key like this makes no dang sense.\n" ]

[]

[]

[ "I should add that if I access the `related_name` references of my M:N table I can get to the associated data — but at the cost of multiple queries (hence the join is sort of useless). I _should_ be able to get two instances from a single query, no? `aggregate_rows()` and `prefetch()` don't seem to apply to this very simple case. Any help is appreciated!\n", "You need to also select the junction table:\n\n``` python\nq = Student.select(Student, StudentTeacher, Teacher).join(StudentTeacher).join(Teacher).where(Student.name == 'Bob')\n```\n\nThen you can access it via:\n\n``` python\nrow.studentteacher.teacher\n```\n" ]

[]

[]

[ "What benefit do you get from having a model that only many-to-many's to another model?\n", "Not to say your issue isn't valid, but just curious as it seems strange.\n", "Well, testing with SQLite, I'm not sure that there's a way to actually `INSERT` \"nothing\" into a table that has only an auto-incrementing primary key.\n\nHere's what Peewee is trying:\n\n``` sql\nINSERT INTO \"failuremodel\"\n```\n\nBut it also fails if I try:\n\n``` sql\nINSERT INTO \"failuremodel\" ()\n```\n\nI think that you might be out of luck on this one.\n", "It does seem a bit weird, but (apart from the syntax errors...) it works quite well - there are a bunch of values stored, and each request to a certain endpoint needs to be stored and connected to those values. Normally I'd just make each value a column, but I'm trying to set the system up so that more values can be added at a later date without having to migrate the database.\n\nAccording to the sqlite docs (https://www.sqlite.org/lang_insert.html), the third form of insert allows you to just write \"DEFAULT VALUES\" instead of specifying them. (According to Google, SQL Server also has the same issue and solution). I don't think this is necessary for mysql or pgsql, although I didn't really look to much into it. Is it possible for peewee to do that?\n\nThanks for replying so quickly!\n", "Having looked a bit further, sqlite and postgreSQL both allow the \"DEFAULT VALUES\" syntax, which replaces the \"VALUES (expr*)\" part of an insert query ([sqlite](https://www.sqlite.org/lang_insert.html), [pg](http://www.postgresql.org/docs/8.2/static/sql-insert.html)). MySQL doesn't allow this, but does allow the \"expr\" part to be replaced by the keyword \"DEFAULT\" ([mysql](http://dev.mysql.com/doc/refman/5.6/en/insert.html)), which does essentially the same thing assuming you know how many columns there are.\n\nI guess the question is whether the default row case (regardless of the number of columns) is a special enough case for peewee to treat it separately and call out to the default value syntaxes for the different DBs. What do you reckon?\n", "Thanks for looking into this, I'll see about updating peewee accordingly.\n", "Thanks!\n" ]

[]

[]

[ "The typical way to handle this is to select the record you're modifying `FOR UPDATE` (see [docs](http://docs.peewee-orm.com/en/latest/peewee/api.html#SelectQuery.for_update)). Here's a [blog post](http://blog.2ndquadrant.com/postgresql-anti-patterns-read-modify-write-cycles/) you might also find useful. Note that this only works with Postgresql.\n", "@coleifer `FOR UPDATE` is for pessimistic locking, while I explicitly need optimistic locking here. A user who opens up data for modification might think for a long time (while modifying a form) and even vanish without never submitting the changes. So, optimistic locking suits my use case better.\n\nIt sounds like there's no builtin support for this. Would you implement it as I sketched above or do you have a more sophisticated approach?\n", "I don't have any plans on adding this to Peewee itself, so you can choose the implementation that best suits your use-case.\n", "@coleifer I finally have to implement this. If I made a PR for it, would consider merging it into peewee? It could work like:\n\n```\nclass MyModel(peewee.Model):\n version = IntegerVersionField()\n\nm = MyModel()\nm.save()\nm1 = MyModel.get()\nm2 = MyModel.get()\nm1.save()\nm2.save() # would throw error\n\nm2.save(optimistic=False) # temporarily disable locking\n```\n\nOr it could be:\n\n```\nclass MyModel(peewee.Model):\n version = IntegerField(default=1)\n\n class Meta:\n version_field = 'version'\n```\n\nI don't have strong opinion on the API, I just wish it was included in peewee and would not break during version upgrades. This touches part of core functionalities (`save()`) so I'm not sure if this could go into playhouse?\n\nIt shouldn't need too many modifications to `Model.save()`, the core idea would be something like:\n\n```\n if self._meta.version_field:\n field_dict[self._meta.version_field] += 1\n rows = self.update(**field_dict).where(self._pk_expr() & (self._meta.fields[self._meta.version_field] == getattr(self, self._meta.version_field))).execute()\n if rows != 1:\n raise Exception(\"Something to indicate that update did not succeed. The cause is probably in version mismatch, but it could be that object with PK was no longer there :|\")\n else:\n rows = self.update(**field_dict).where(self._pk_expr()).execute()\n```\n\nMaybe something more sophisticated than `getattr` etc.\n\nI am personally doing locking based on integer version field, but it could be timestamp, hash, or anything.\n\nWhat do you think?\n", "That's pretty cool, but honestly I think that is just enough beyond the\nscope that I'd rather it live as its own project. By all means you can\ncreate your own base middle class that overrides save.\n\nThere is enough complexity there that I think I could get bogged down\nsupporting exotic edge cases or who knows, and really I want to focus on\npeewee.\nOn Dec 7, 2015 2:39 AM, \"Tuukka Mustonen\" [email protected] wrote:\n\n> @coleifer https://github.com/coleifer I finally have to implement this.\n> If I made a PR for it, would consider merging it into peewee? It could work\n> like:\n> \n> class MyModel(peewee.Model):\n> version = IntegerVersionField()\n> \n> m = MyModel()\n> m.save()\n> m1 = MyModel.get()\n> m2 = MyModel.get()\n> m1.save()\n> m2.save() # would throw error\n> \n> m2.save(optimistic=False) # temporarily disable locking\n> \n> Or it could be:\n> \n> class MyModel(peewee.Model):\n> version = IntegerField(default=1)\n> \n> ```\n> class Meta:\n> version_field = 'version'\n> ```\n> \n> I don't have strong opinion on the API, I just wish it was included in\n> peewee and would not break during version upgrades. This touches part of\n> core functionalities (save()) so I'm not sure if this could go into\n> playhouse?\n> \n> It shouldn't need too many modifications to Model.save(), the core idea\n> would be something like:\n> \n> ```\n> if self._meta.version_field:\n> field_dict[self._meta.version_field] += 1\n> rows = self.update(**field_dict).where(self._pk_expr() & (self._meta.fields[self._meta.version_field] == getattr(self, self._meta.version_field))).execute()\n> if rows != 1:\n> raise Exception(\"Something to indicate that update did not succeed. The cause is probably in version mismatch, but it could be that object with PK was no longer there :|\")\n> else:\n> rows = self.update(**field_dict).where(self._pk_expr()).execute()\n> ```\n> \n> Maybe something more sophisticated than getattr etc.\n> \n> I am personally doing locking based on integer version field, but it could\n> be timestamp, hash, or anything.\n> \n> What do you think?\n> \n> —\n> Reply to this email directly or view it on GitHub\n> https://github.com/coleifer/peewee/issues/658#issuecomment-162448760.\n", "Personally I would love to see this as part of peewee, as it's something I found useful when I was using Ruby's ActiveRecord. Until now I wasn't doing optimistic locking in my peewee based projects, just because I was lazy to implement it myself...\n\n@tuukkamustonen if you end up implementing it in a separate lib, please post the link here. \nAnd about your suggested implementation - I suggest using a dedicated exception, so it can be properly handled by using code.\n", "@tuukkamustonen: just throwing a +1 here - if this is something you've already written, I'd love to see the code!\n", "@arikfr @tconkling Well, I am just pasting here the code I'm running atm. Maybe @coleifer wants to sanity check it, too.\n\nI am not running it in production, nor do I have extensive test suite for it. It's just something I threw in for now, and I actually had it back in my head to ask for comments at some point.\n\nThe big drawback is that this code is pretty much bound to a specific peewee version, because it re-writes the whole `save` method. Of course, one could rename it differently, but, well.\n\nA model is defined by:\n\n```\nclass MyModel(LockableModel):\n\n class Meta(object):\n version_field = 'version'\n\n version = IntegerField(default=1)\n```\n\nIt only supports numeric locking field.\n\nAnd the actual implementation (my only additions are the two blocks with `# Comments`):\n\n```\nclass ConcurrentModification(PeeweeException):\n \"\"\"Indicates that entity has been changed in the database between loading and saving.\"\"\"\n\nclass LockableModel(peewee.Model):\n\n # The base was copied from peewee 2.7.4\n def save(self, force_insert=False, only=None, optimistic=True):\n field_dict = dict(self._data)\n if self._meta.primary_key is not False:\n pk_field = self._meta.primary_key\n pk_value = self._get_pk_value()\n else:\n pk_field = pk_value = None\n if only:\n field_dict = self._prune_fields(field_dict, only)\n elif getattr(self._meta, 'only_save_dirty', False) and not force_insert:\n field_dict = self._prune_fields(\n field_dict,\n self.dirty_fields)\n # Empty dict is ok with optimistic locking (to simply increment version)\n # XXX: Is this really needed? There is no use case for this!\n if not field_dict and (\n not getattr(self._meta, 'version_field', None) or (\n getattr(self._meta, 'version_field', None) and not optimistic\n )\n ):\n self._dirty.clear()\n return False\n\n self._populate_unsaved_relations(field_dict)\n if pk_value is not None and not force_insert:\n if self._meta.composite_key:\n for pk_part_name in pk_field.field_names:\n field_dict.pop(pk_part_name, None)\n else:\n field_dict.pop(pk_field.name, None)\n\n # Locking\n if optimistic and getattr(self._meta, 'version_field', None):\n # Add and increment version field, if it was not manually given. This is the normal behavior\n if self._meta.version_field in field_dict:\n raise ValueError('You must not modify version field manually while using locking!')\n field_dict[self._meta.version_field] = self._data[self._meta.version_field] + 1\n rows = self.update(**field_dict).where(\n self._pk_expr() &\n (\n self._meta.fields[self._meta.version_field] ==\n getattr(self, self._meta.version_field)\n )\n ).execute()\n if rows == 0:\n entity = self.select().where(self._pk_expr()).get() # throws DoesNotExist if not found, but it should...\n raise ConcurrentModification(\n 'Tried to save entity with version of `{}` but database contains entry with version of `{}`!'\n .format(field_dict[self._meta.version_field], getattr(entity, self._meta.version_field))\n )\n # Also set correct version on this instance, if update succeeded\n setattr(self, self._meta.version_field, field_dict[self._meta.version_field])\n\n else:\n rows = self.update(**field_dict).where(self._pk_expr()).execute()\n elif pk_field is None:\n self.insert(**field_dict).execute()\n rows = 1\n else:\n pk_from_cursor = self.insert(**field_dict).execute()\n if pk_from_cursor is not None:\n pk_value = pk_from_cursor\n self._set_pk_value(pk_value)\n rows = 1\n self._dirty.clear()\n return rows\n```\n\nSo, calling `save()` does the usual optimistic locking stuff, and calling `save(optimistic=False)` disables the feature.\n", "Cool, I'll play with this myself!\n\nIt seems like something @coleifer could possibly support by breaking out some of the `save()` functionality out into several other functions that custom subclasses, like your optimistic-locking model, could override?\n" ]

[]

[]

[ "Are all of your models explicitly referencing your db?\n\n``` python\ndb = SqliteDatabase('mydb')\nclass SomeModel(Model):\n data = CharField()\n class Meta:\n database = db # do you have this?\n```\n", "Yes, they are. I followed the examples and have a BaseModel that references the database, and that all the other models extend. For when I am trying to connect form a different folder, I use the absolute path to the database for the <code>db = SqliteDatabase('absolute-path-to-database')</code> \n\nIf it helps, the script that I am using to create and connect to the database is located here: \nhttps://github.com/jacobbieker/Insights/blob/dev/databaseSetup.py\n\nI import that file into the other scripts to access the database, unless there is a better way to do it?\n", "Can you share your code?\n", "Yes, here is where I connect to a database that is run whenever databaseSetup is imported, the whole file is here: https://github.com/jacobbieker/Insights/blob/dev/databaseSetup.py:\n\n```\nif __name__ != \"__main__\":\n with open(os.path.join(\"..\", \"constants.yaml\"), 'r') as ymlfile:\n config = yaml.load(ymlfile)\nelse:\n with open(\"constants.yaml\", 'r') as ymlfile:\n config = yaml.load(ymlfile)\nclass BaseModel(peewee.Model):\n class Meta:\n database = SqliteDatabase(config.get('databaseLoc')).connect()\n\n class Locations(BaseModel):\n date = DateTimeField(null=True)\n time = TimeField(null=True)\n longitude = DoubleField(null=True)\n latitude = DoubleField(null=True)\n continent = CharField(null=True)\n country = CharField(null=True)\n state = CharField(null=True)\n zip = IntegerField(null=True)\n city = CharField(null=True)\n street = TextField(null=True)\n name = TextField(null=True)\n```\n\nWhere 'databaseLoc' is the absolute path to the desired database\n\nAnd here is the relevant code in a script that imports \n\nLocations2SQLite.py, located here: https://github.com/jacobbieker/Insights/blob/dev/GoogleTakeoutScripts/Location2SQLite.py\n\n```\nfrom databaseSetup import Locations\n\n Locations.insert(date=converted_time_stamp,time=time_stamp, longitude=longitude, latitude=latitude,\n continent=continent, country=country, state=state, zip=zipcode, city=city, street=street,\n name=building).execute()\n```\n\nWhen Locations2SQLite.py exits, it creates a peewee.db in its directory, and does not connect to the database created in databaseSetup.py \n", "The problem is you're calling `database.connect()` in the `Meta` inner class -- not sure why you're doing that there, since the return value of `connect` would not be a database instance.\n\nChange it to the following and you should be fixed:\n\n``` python\nclass BaseModel(peewee.Model):\n class Meta:\n database = SqliteDatabase(config.get('databaseLoc'))\n```\n", "That worked! Thanks for the help.\n" ]

[]

[]

[ "Rather than adding this to Peewee itself, I'd suggest you write your own wrapper that does what you want:\n\n``` python\nfrom peewee import *\nimport time\n\ndb = PostgresqlDatabase('whatever')\n\ndef connect_db(retries=3, delay=5):\n while True:\n retries -= 1\n try:\n db.connect()\n except OperationalError:\n if retries == 0:\n raise\n time.sleep(delay)\n else:\n return True\n```\n", "Since we're using a `Proxy`, how would we override the `connect` call (or would we have to just make sure to call our own connect first everytime)?\n", "Using the function from above, I imagine you would just write:\n\n``` python\ndef connect_db(db, retries=3, delay=5):\n while True:\n retries -= 1\n try:\n db.connect()\n except OperationalError:\n if retries == 0:\n raise\n time.sleep(delay)\n else:\n return True\n\nclass ReconnectingProxy(Proxy):\n def connect(self):\n return connect_db(self.obj)\n\ndatabase = ReconnectingProxy()\ndatabase.initialize(some_other_db)\n```\n" ]

[]

[]

[ "You need to save with `force_insert=True`.\n\nhttp://docs.peewee-orm.com/en/latest/peewee/models.html#id3\n", "I can't believe I missed that in the docs, my bad :( Thanks for the reply!\n", "Fwiw, do you think it's worth patching so that an exception is raised if this situation is ever encountered? Although it's documented, it would be nice to have an exception raised in the event of human error maybe.\n", "This definitely needs exception or some kind of logging, failing silently is not cool.", "It *does* work, Peewee just assumes if the PK is present that it should do an update instead. Peewee is an active-record ORM. This is fundamental stuff." ]