Datasets:

---

akumoth

/

peewee-issues

like 0

[]

[]

[ "Responded to this when you asked on a different issue: https://github.com/coleifer/peewee/issues/2064#issuecomment-654236281\r\n\r\nThe alternative is to maintain a list of all sql reserved words and only quote words when they happen to collide with a sql keyword, and that seems silly. Quoting identifiers is the best way to handle this. Similarly, I've seen people who use whitespace and all kinds of other unexpected things in their sql identifiers. Quoting ensures that they work in all cases." ]

[]

[]

[ ">I have solved this with MailCode.alias()\r\n\r\nThis is the peewee-official way to do reference the same table in multiple contexts within a single query." ]

[]

[]

[ "never heard of it. Read the manual:\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/database.html#adding-a-new-database-driver" ]

[]

[]

[]

[]

[]

[ "CockroachDB provides this function out-of-the-box. Postgres requires an extension, so it is not provided as a built-in. It is quite easy to add this if you want it, though -- just use the implementation from cockroachdb or create your own subclass.", "PostgreSQL 13 \r\nhttps://www.postgresql.org/docs/13/functions-uuid.html" ]

[]

[]

[]

[]

[]

[ "You're probably using an older version of Sqlite(?) or otherwise the database is generating a column-name for your MAX value like 'MAX(\"t1\".\"score\")'. Just specify an alias:\r\n\r\n```python\r\nfn.MAX(Comment.score).alias('max_score')\r\n```\r\n\r\nThen it will be available as the \"max_score\" attribute.", "Sorry yes I should have mentioned SQLite! For your reference I am using 3.22, it has a version tag `3.22.0 2018-01-22 18:45:57` . Regards." ]

[]

[]

[]

[]

[]

[ "No, that's not really do-able, as each database tends to require it's own form of syntax and operations.", "You could try to apply a hook when the database proxy is initialized, which at that point would add the correct Json field to the model instance, I guess?", "Digging into `peewee` code, I came across https://github.com/coleifer/peewee/blob/master/peewee.py#L4904-L4928 which seems to have a different behavior depending on the database in use.\r\n\r\nWouldn't it be possible to somehow unify https://github.com/coleifer/peewee/blob/master/playhouse/sqlite_ext.py#L122-L194 and https://github.com/coleifer/peewee/blob/master/playhouse/postgres_ext.py#L294-L320 in a single `JSONField` class with a similar approach, with actual implementation depending on the database object?\r\n\r\nBeyond the quick and dirty hack, I guess this would require either moving this code from Playhouse to Peewee core or making a super `*Database` class in Playhouse which would supercede the `*Database` classes from Peewee.\r\n\r\n\r\nThis is something I regularly need and the usual way to fix this is to create from scratch and naive `JSONField` (no knowledge of the JSON structure, just encoded/decoded from text field). If something generic as described above is achievable here in a robust way, I can definitely help write and test it." ]

[]

[]

[ "I can't see a problem in the SQL being generated. Can you provide the SQL for a working version and highlight the differences? Also what database are you using?", "PostgreSQL12\r\n\r\n", "Can you provide the SQL for a working version?", "```\r\nquery3 = Bookchapter.select(\r\n Bookchapter.id,\r\n Bookchapter.chapter,\r\n)\r\n\r\ntt = Books.insert_from(query3, fields=[\r\n Books.id,\r\n Books.chapter\r\n]).on_conflict(\r\n conflict_target=[Books.id],\r\n update={Books.chapter: Bookchapter.chapter}\r\n).sql()\r\n\r\nprint(tt)\r\n```\r\n\r\n```\r\n<peewee.PostgresqlDatabase object at 0x10d7571c0>\r\n('INSERT INTO \"books\" (\"id\", \"chapter\") SELECT \"t1\".\"id\", \"t1\".\"chapter\" FROM \"bookchapter\" AS \"t1\" ON CONFLICT (\"id\") DO UPDATE SET \"chapter\" = \"t1\".\"chapter\"', [])\r\n```\r\n", "I thought you said it was not working. Please share the sql to a version of the query that works.", "The proper way to write this is to reference the \"new\" update-value using `EXCLUDED`. Peewee provides a shortcut, which is the `preserve` option.\r\n\r\n```python\r\nBooks.insert_from(query3, fields=[\r\n Books.id,\r\n Books.chapter\r\n]).on_conflict(\r\n conflict_target=[Books.id],\r\n preserve=[q.c.name] # Note we're referencing the name here.\r\n)\r\n```\r\n\r\nYou can also write:\r\n\r\n```python\r\n.on_conflict(\r\n conflict_target=[Books.id],\r\n preserve=['name'] # Name of column to preserve (\"carry over\") from insert.\r\n)\r\n```" ]

[]

[]

[]

[]

[]

[ "It seems like `Person` does not inherit `Model`. You did not put the code for `Person` so it's just a guess.", "Thanks for the reply.\r\n\r\nHowever, I do have Person inherit Model.\r\n\r\nCode:\r\n> from peewee import *\r\n> class Person(Model):\r\n\r\nAlso tried\r\n> import peewee\r\n> class Person(peewee.Model):" ]

[]

[]

[ "No" ]

[]

[]

[ "I'm following the examples provided here in pg's doc: https://www.postgresql.org/docs/current/queries-table-expressions.html#QUERIES-LATERAL\r\n\r\nI suppose we probably also need to support an inner lateral join, too, though I'm not sure how that would be used.", "The way I'm currently going to address this is to add the `lateral()` method to the select query class.\r\n\r\nThis gives you the opportunity to use joins more naturally, and signifies only that the subquery being joined should be interpreted as a lateral join, which I think is more \"correct\" anyways.\r\n\r\nExample:\r\n\r\n```python\r\n\r\n# Here we use a subquery to get the most-recent two tweets by each user.\r\nsubq = (Tweet\r\n .select(Tweet.content, Tweet.timestamp)\r\n .where(Tweet.user == User.id)\r\n .order_by(Tweet.timestamp.desc())\r\n .limit(2)\r\n .lateral())\r\n\r\n# Here we do an inner join on the (lateral) subquery of tweets.\r\nquery = (User\r\n .select(User, subq.c.content)\r\n .join(subq, on=True)\r\n .order_by(subq.c.timestamp))\r\n```", "The example that you referred to with only `LATERAL` is actually multiple `FROM` clause, which needs a comma between them. \r\n\r\n\r\n\r\nAbove clause is equivalent to `INNER JOIN LATERAL` or just `JOIN LATERAL`.\r\n\r\nI do like the current API of `LATERAL` though (`.join(sq, join_type=JOIN.LATERAL)`), and I noticed there is also `CROSS JOIN LATERAL` too." ]

[]

[]

[ ">When there's a database error, postgres leaves me in a failed transaction.\r\n\r\nYes, in which case you should issue a rollback.\r\n\r\nPeewee is currently designed to work *with* psycopg2's transaction handling. Setting `autocommit=True` may break Peewee's transactional APIs or may have other unintended consequences. Unless you're very familiar with both peewee's transaction semantics and psycopg2's, I wouldn't recommend setting pg to autocommit.\r\n\r\nIf the issue is simply that you are issuing queries that fail due to errors, I suggest you fix your queries to make them more robust, and wrap them with peewee's `atomic` (or ensure that you properly roll-back upon a query failure).\r\n\r\nBy the way, your traceback is not relevant I don't think, since that is the query you are attempting to execute *after* a previous query failed." ]

[]

[]

[ "This is a question about some scraping library you are using. peewee issue tracker is not for questions, much less questions about a completely unrelated and unidentified html library.\r\n" ]

[]

[]

[ "I'm sorry but I don't understand the question, what these special field subclasses are, or really what the problem is." ]

[]

[]

[ "One may still want the option to apply converter logic, so converter is not explicitly disabled." ]

[]

[]

[ "Thanks for reporting. This bug was caused by modifying an internal flag on the expression node without copying it first. This caused subsequent usages of that expression node to carry-over the flag when they shouldn't have." ]

[]

[]

[ "Thanks for reporting. This is a bug and has to do with peewee performing redundant trips through the model graph." ]

[]

[]

[ "First result on google my dude.\r\n\r\nhttps://stackoverflow.com/questions/58720894/check-a-materialized-view-exists", "I know how to use the `pg_class` table, \"my dude\", I was asking if this can be do directly in Peewee using its API. I won't be opening any more issues trying to improve Peewee since there doesn't seem to be an interest for it." ]

[]

[]

[ "BinaryUUIDField is tested against all databases, including MySQL, and seems to work just fine.\r\n\r\nIf you can produce a failing test-case I will look into it some more.", "https://github.com/coleifer/peewee/blob/master/tests/fields.py#L841-L897", "I ran the tests, and the warning is generated by them. The fields however are generated so there must be something else wrong with my code. However, the warnings end up in my logs and fill up the logs unnecessarily. It seems with mysql, ALL binary fields should be prefaced with the \"introducer\" _binary\r\nlike so:\r\n\r\nreplace:\r\n\r\ncursor.execute(\"\"\"\r\n INSERT INTO `user` (uuid)\r\n VALUES (%s)\r\n\"\"\", my_uuid)\r\n\r\nwith\r\n\r\ncursor.execute(\"\"\"\r\n INSERT INTO `user` (uuid)\r\n VALUES (_binary %s)\r\n\"\"\", my_uuid)", "I'd suggest taking it up with the pymysql devs.", "There is a connection option \"binary_prefix=True\" i am experimenting to see if it fixes the issue. ", "Ok, I can confirm if you pass \"binary_prefix=True\" to the init the spurious warning goes away.\r\nlike so:\r\n\r\n```\r\ndb = MySQLDatabase(None)\r\n\r\n...\r\n db.init(\r\n dbname,\r\n host=dburl,\r\n user=dbuser,\r\n password=dbpassword,\r\n charset=\"utf8mb4\",\r\n binary_prefix=True,\r\n )\r\n```\r\n\r\npymysql does not do it by default because some orms do it for themselves. Would suggest at the very least a comment in the docs relating to peewee and mysql, in much the same way charset is documented.", "Since MySQL is raising warnings because of binary data being stored into a VARBINARY column, I really think this is a MySQL bug. I read their issue tracker and frankly it's a complete bullshit response. Prefixing with \"_binary\" is the workaround they suggest, or alternatively using a literal parameter prefixed with \"x\". Neither of these is palatable to me for inclusion in Peewee. I'd suggest that MySQL users just use the regular UUIDField instead, which stores the hex representation at the cost of a few more bytes of storage... Or switch to MariaDB, which doesn't seem to have this problem.", "`charset` is not really documented per-se, but rather given as an example that you should consult your driver documentation. Not everyone who uses Peewee with MySQL will be using pymysql, so you're encouraged to read the docs for whichever db driver you're using.", "Yeah, i agree its a bullshit response on the mysql side. Its not a true warning, its just pointless noise and they know it. I would use a different DB but i am limited by what the company chose. For my part, it works fine with the option, if anyone else has the issue i am sure they will find this thread in the issues and see the workaround. Sorry for saying the UUID didn't work. It clearly does. I must have had another issue and was being bamboozled by the crap warning. Its OT, but i am actually really liking peewee so, thankyou.\r\n\r\nTo be honest, these sorts of workarounds should be in the driver, again i don't know why its so difficult for pymysql to check binary fields and prefix them if they are not already prefixed. But cest la vie.", "No worries at all, I understand the confusion. I am surprised I hadn't seen this come up until now, but I'm glad the driver at least provides some measure of workaround." ]

[]

[]

[ "Try using `.objects()` instead at the end of your \"non-raw\" query, which will skip the model-join graph reconstruction step. You don't need it as you're only selecting from one table and it seems to be the issue.", "I'm having a bit of trouble parsing-out exactly what your query is designed to accomplish. There's a bit of unnecessary cruft in there (filegroup, e.g.). Can you make a smaller, more semantic example so I can get a better handle on what you're trying to accomplish?", "> Try using .objects()\r\n\r\nIt works.\r\n\r\n> Can you make a smaller\r\n\r\nI will try do it. This is a visualization diagram. Code will go below.\r\n\r\n\r\n\r\nI renamed FileGroup to Storage.\r\n\r\nOne Storage is related with many files (by storing Storage id in File relation) and several Folders (also Folder related with Storage by id).\r\n\r\nOne Folder is related to one Storage.\r\n\r\nOne File is related with one Storage and one Folder.\r\n\r\nOne Folder is related to many Files but File do not explicitly bound with Folder by id. Instead, File and Folder are implicitly bound through:\r\n\r\n```sql\r\nfile.storage = folder.storage AND\r\nfile.filename_info = filebasename.id AND\r\nCAST(filebasename.type AS TEXT) = CAST(folder.type AS TEXT)\r\n```\r\n\r\nThere is a way to avoid this strange things by defining foreign key references folder.id.\r\n\r\nAlso to rewrite the query as it will follow below.\r\n\r\nI don't like the first way because this implicit bind is uniquely specified so you don't need to have an additional field in the large File table.\r\n\r\nI don't like folder_another_way() and folder_another_way_2() because they do not show that this bind is implicit.\r\n\r\n```python\r\nimport logging\r\nimport traceback\r\n\r\nfrom peewee import JOIN, CharField, ForeignKeyField, Model, SqliteDatabase\r\n\r\ndatabase = SqliteDatabase(\":memory:\")\r\n\r\n\r\nclass BaseModel(Model):\r\n class Meta:\r\n database = database\r\n\r\n\r\nclass Storage(BaseModel):\r\n name = CharField()\r\n\r\n\r\nclass Folder(BaseModel):\r\n storage = ForeignKeyField(model=Storage)\r\n type = CharField() # Enum in DB\r\n\r\n\r\nclass FileBasename(BaseModel):\r\n string = CharField()\r\n type = CharField() # Enum in DB with the same values as in Folder.type\r\n\r\n\r\nclass File(BaseModel):\r\n storage = ForeignKeyField(model=Storage)\r\n filename_info = ForeignKeyField(model=FileBasename, backref='files')\r\n\r\n def folder(self):\r\n query = (\r\n Folder.select()\r\n .join(File, join_type=JOIN.CROSS)\r\n .join_from(File, FileBasename)\r\n .where(\r\n self._pk_expr() &\r\n (File.storage == Folder.storage) &\r\n (FileBasename.type.cast('TEXT') == Folder.type.cast('TEXT'))\r\n )\r\n )\r\n result = query.execute()\r\n return result[0] if result else None\r\n\r\n def folder_raw(self):\r\n query = (\r\n Folder.select()\r\n .join(File, join_type=JOIN.CROSS)\r\n .join_from(File, FileBasename)\r\n .where(\r\n self._pk_expr() &\r\n (File.storage == Folder.storage) &\r\n (FileBasename.type.cast('TEXT') == Folder.type.cast('TEXT'))\r\n )\r\n )\r\n sql, params = query.sql()\r\n result = Folder.raw(sql, *params).execute()\r\n return result[0] if result else None\r\n\r\n def folder_another_way(self):\r\n query = (\r\n Folder.select()\r\n .join(File, on=(File.storage == Folder.storage))\r\n .join_from(File, FileBasename)\r\n .where(\r\n self._pk_expr() &\r\n (FileBasename.type.cast('TEXT') == Folder.type.cast('TEXT'))\r\n )\r\n )\r\n result = query.execute()\r\n return result[0] if result else None\r\n\r\n def folder_another_way_2(self):\r\n query = (\r\n Folder.select()\r\n .join(Storage)\r\n .join(File)\r\n .join(FileBasename)\r\n .where(\r\n self._pk_expr() &\r\n (FileBasename.type.cast('TEXT') == Folder.type.cast('TEXT'))\r\n )\r\n )\r\n result = query.execute()\r\n return result[0] if result else None\r\n\r\n\r\nif __name__ == \"__main__\":\r\n database.create_tables(\r\n models=[Storage, FileBasename, File, Folder])\r\n with database.atomic():\r\n storage = Storage.create(name=\"first storage\")\r\n Folder.create(type=\"first type\", storage=storage)\r\n filename_info = FileBasename.create(\r\n type=\"first type\", string=\"base part of some name\")\r\n File.create(storage=storage, filename_info=filename_info)\r\n\r\n file = File.get_by_id(1)\r\n\r\n logger = logging.getLogger('peewee')\r\n logger.addHandler(logging.StreamHandler())\r\n logger.setLevel(logging.DEBUG)\r\n\r\n try:\r\n print(\"This won't be printed:\", repr(file.folder()))\r\n except Exception:\r\n traceback.print_exc()\r\n\r\n print(\"Let's try with raw():\", repr(file.folder_raw()))\r\n print(\"And now another way:\", repr(file.folder_another_way()))\r\n print(\"Another way #2:\", repr(file.folder_another_way_2()))\r\n\r\n```\r\n", "This is more or less the way I would have expected the query to be written:\r\n\r\n```python\r\n def folder_another_way(self):\r\n query = (\r\n Folder.select()\r\n .join(File, on=(File.storage == Folder.storage))\r\n .join_from(File, FileBasename)\r\n .where(\r\n self._pk_expr() &\r\n (FileBasename.type.cast('TEXT') == Folder.type.cast('TEXT'))\r\n )\r\n )\r\n result = query.execute()\r\n return result[0] if result else None\r\n```" ]

[]

[]

[ "```python\r\n\r\nsubq = (MyEntity\r\n .select(MyEntity.value_1)\r\n .where((MyEntity.ClientId == i) | (MyEntity.date == z)))\r\n .alias('subquery'))\r\nMyEntity.select(fn.MAX(subq.c.value_1)).from_(subq)\r\n```" ]

[]

[]

[ "Peewee puts stuff on the model it belongs to. You're just aliasing the author's first-name, so peewee puts that on the author model. When you have an expression where it is unclear what model it belongs to, then it gets placed on the root/selected model.\r\n\r\nIf you don't want to be dealing with a graph of models, just use `.objects()` at the end of your query and *all* attributes will be placed on the root/selected model." ]

[]

[]

[]

[]

[]

[ "Thanks for the heads-up. I wonder how they intend to reference the selected column. Anyways we'll cross that bridge when we get there." ]

[]

[]

[]

[]

[]

[ "wow that was fast.", "@coleifer The build failed for some reason might want to revert?", "https://travis-ci.org/github/coleifer/peewee/builds/691771699" ]

[]

[]

[ "Discussed and dismissed many times, notably #263. There are so many things I dislike about the ~twisted~ asyncio approach, mostly the fact that you have to write \"asyncio\"-specific everything -- drivers, ORMs, application frameworks, etc., etc. and even then you still have a \"[what color is my function](https://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/)\" situation.\r\n\r\nUse gevent. Seriously. You can thank me later.", "A commenter suggested [tortoise orm](https://tortoise-orm.readthedocs.io/en/latest/) - I cannot vouch for it, but wanted to preserve the recommendation for anyone who arrives here via google.", "@coleifer it's very sad that you ignore the `async/await` syntax. A lot of people/products use it these days and it's not only about `asyncio`. I know about the tortoise ORM, but I prefer Peewee syntax.\r\n\r\nMaybe we have a chance to split the Peewee ORM and make a code that working with DB connections independently. So there will be drivers independent Peewee part which one only is responsible for the conversation Models <-> SQL and another part that implement database connection management. That way people could be available to use Peewee with any sync/async drivers.", "@klen - I wouldn't say that I ignore it, but I do not like the approach (for a number of reasons) and prefer the gevent approach for Python. The main reason I dislike it is because it requires a special \"asyncio-aware\" version of every piece of software in the stack.\r\n\r\nThis project exists, which might prove useful for people finding this issue in the future:\r\n\r\nhttps://github.com/05bit/peewee-async", "As an alternative, there is another library: https://github.com/klen/peewee-aio" ]

[]

[]

[ "Yes, we evaluate it at class-creation time. I'm going to pass on the solutions proposed, as they seem rather specific to whatever you're doing." ]

[]

[]

[ ">The following code is just an example. It will not throw an exception.\r\n\r\nIf you can produce code that reliably causes problems, I will be happy to investigate... Did you hand-write that traceback, though? I'm confused because you have said that the code does *not* produce an error, but then you have pasted what looks like an error from such code.", "I am sorry for confusing you. This is the real traceback from my project, I just replaced class names. I wanted to give a clear example because I cannot copy here all of my models.\r\n\r\nAnyway, I found that makes model unhashable. I defined custom `__eq__` without `__hash__`.\r\nNow this code will produce an error.\r\n```python\r\nimport traceback\r\n\r\nfrom peewee import (CharField, ForeignKeyField, Model,\r\n SqliteDatabase)\r\n\r\ndatabase = SqliteDatabase(\":memory:\")\r\n\r\nclass BaseModel(Model):\r\n class Meta:\r\n database = database\r\n def __eq__(self, other):\r\n return super().__eq__(other)\r\n # def __hash__(self):\r\n # \"\"\"If it isn't defined, when __eq__ is defined, object is unhashable\r\n # https://stackoverflow.com/questions/1608842/types-that-define-eq-are-unhashable\"\"\"\r\n # return super().__hash__()\r\n\r\nclass A(BaseModel):\r\n some_str = CharField()\r\n\r\nclass B(BaseModel):\r\n another_str = CharField()\r\n a = ForeignKeyField(model=A)\r\n\r\nif __name__ == \"__main__\":\r\n database.create_tables(models=[A, B])\r\n a = A.create(some_str='s1')\r\n b = B.create(another_str=f's2', a=a)\r\n try:\r\n for b in B.select(B, A).join(A):\r\n print(b)\r\n except:\r\n traceback.print_exc()\r\n```\r\n<details>\r\n<summary>Screenshot</summary>\r\n\r\n</details>", "Why are you implementing a custom `__eq__()` on a peewee model class? The peewee model class already implements a correct equals (and hash). I suggest you refer to the peewee source code and review the implementations there. This is a Python thing -- you'll need to also implement a hash method if you are overriding equals -- but I'd strongly suggest you just use the default implementations in peewee.", "> Why are you implementing a custom `__eq__()` on a peewee model class?\r\n\r\nMy code logic with kludges needs this. I check if an instance updated in a DB excluding some fields from a `list` defined in model classes.\r\n\r\nAt the same time, I try to write efficient queries, because I know a little SQL. These I like `peewee` that it is flexible and similar to SQL.\r\n\r\n> This is a Python thing -- you'll need to also implement a hash method if you are overriding equals\r\n\r\nI already understood this as I wrote above.\r\n\r\n> I'd strongly suggest you just use the default implementations \r\n\r\nI will follow your advice and will rename custom `__eq__()` to something like `equal_to()` then it will not affect on the `peewee` default implementation.\r\n\r\n> I suggest you refer to the peewee source code and review the implementations there.\r\n\r\nI read and tried to understand `ModelCursorWrapper.process_row()`. Please take five minutes to look into it. \r\nhttps://github.com/coleifer/peewee/blob/d6318dce0e5149a61511521a7dcb96600bec9b25/peewee.py#L7519-L7523\r\nThis condition in the `if` will never be `True`. `instance` cannot contains in `set_keys` due to the `set_keys` stores model classes and `instance` is a model instance. It looks like `src` must be instead of `instance` there.\r\n\r\nIf you will have time, I am also interesting in cases covered by this `if` because I could not imagine them when I was trying to find cases that would be affected by this typo. Thanks a lot!\r\n", "The condition is to avoid populating non-selected intermediary models.", "> This condition in the if will never be True. \r\n\r\nSorry, I made a typo. I mean that the \"`instance not in set_keys`\" part of the `if` condition will never be `False`. The full condition can be both `True` or `False` of course.\r\n", "I suggest you try removing the clause and running the tests, if you're curious." ]

[]

[]

[ "Also related, the [docs](https://github.com/coleifer/peewee/blame/master/docs/peewee/playhouse.rst#L688) mention (and try linking to) `DateTimeTZ` (as opposed to `DateTimeTZField`) resulting in a broken link", "How can a time have a timezone, when the time's value is dependent on the date it's attached to? At any rate, you can subclass `TimeField` and provide your own field-type. Creating field types is super easy, especially when they are derived from existing field.\r\n\r\nThanks for the note about the docs, I've fixed it.", "Postgres has a [datatype that's just a time](https://www.postgresql.org/docs/current/datatype-datetime.html) (no date) with a timezone. This makes sense because I can say \"7PM EST\" and convert it to UTC without ever needing to get a date involved.\r\n\r\nPython's `datetime.time` also supports timezones with its `tzinfo` attribute.\r\n\r\nI understand if you don't want to add it, and can go with the custom field, but to me it seems strange to have first class support for the `timestamp with time zone` datatype but not the `time with time zone` one." ]

[]

[]

[ "It isn't calling `db_value()` because peewee sees that you're using a model class as a value, which is a recognized AST type. The issue that originated this fix is #2131.", "Thanks for reporting, this is fixed in master now.", "Thank you! I just wanted to drop a note saying how much I've enjoyed using peewee and how appreciative I've been have your responsiveness to issues." ]

[]

[]

[ "StackOverflow for questions.\r\n\r\nYou need to properly join on your relation and then array-agg over the result column you are trying to aggregate..." ]

[]

[]

[ "Did you try this?\r\n\r\n```python\r\nmul = ((Listing.sale_price * Listing.yearly_rent)).cast('float')\r\navg = fn.avg(mul).alias('avg')\r\nmul = mul.alias('mul')\r\n```", "Thank you; yes, this works!\r\nBut, I would expect peewee to implicitly turn off alias when used in irrelevant cases.", "To do this it would have to recursively inspect every sub-node in the tree... eg. a function call would have to recursively inspect each of it's arguments. Peewee doesn't do this to avoid overhead. The workaround I suggested is the best way to handle it." ]

[]

[]

[ "I'm guessing you added that column to your model class without also ensuring it was added to the database. Try dropping and recreating your table, or migrating the schema using the migrate extension.\r\n\r\nPlease post questions on stackoverflow from now on. This is the issue tracker." ]

[]

[]

[]

[]

[]

[ "Peewee has a very easy-to-use migrations helper that you can use to modify your schema. At the time of writing, an automatic \"detect changes and generate migrations\" tool is not part of Peewee and likely will not be added at any time. Such tools carry a very large maintenance burden and are buggy, and bugs can have disastrous effects on your db if you aren't careful. I prefer explicit migrations, and Peewee supports that.\r\n\r\nYou're welcome to use a 3rd party tool, but I can't vouch for any of them, not having used them myself." ]

[]

[]

[ "Thanks, switched to RLock." ]

[]

[]

[ "10.0 was released in 2012... So are you using an 8+ year old version of MariaDB?\r\n\r\nYou can also suppress warnings if that's your preference: https://docs.python.org/3/library/warnings.html#temporarily-suppressing-warnings", "Yes. And I'm not happy about it either :) So at this point, my opinion (and I am probably the only one with it) is that I think your warning is inaccurate and it should thereby be fixed because the MariaDB version **is** known .... it's just seriously outdated and shouldn't be used. Oh - and the reason for it being old is it is what was shipped on the Synology DiskStation and I'm just using it temporarily so don't judge me too harshly. " ]

[]

[]

[ "I commented on your identical issue earlier.\r\n\r\nhttps://github.com/coleifer/peewee/issues/2176#issuecomment-628016499" ]

[]

[]

[ "I am unclear what you are asking. Perhaps you have a mysql setting enabled that causes it to use default/empty values instead of raising an exception?\r\n\r\nAt any rate, this is not a peewee issue but a mysql question. Please take it to stackoverflow." ]

[]

[]

[ "Autoconnect was not present in 3.7.0: https://github.com/coleifer/peewee/blob/3.7.0/peewee.py#L2531-L2532" ]

[]

[]

[ "If you can create a reproducible test-case I would be happy to investigate. As it is, the reflection module is already tested and I can assure you that it is not as fundamentally broken as all that.\r\n\r\nhttps://github.com/coleifer/peewee/blob/3b1181a7cf727cc749a5fbb76f96602a3bb3325b/tests/reflection.py#L77-L443", "Figure it out. The problem is that I was using a user that doesn't own the tables being reflected. The query that retrieves the primary keys uses the view `table_constraints` which, according to Postgresql\r\n\r\n> The view table_constraints contains all constraints belonging to tables that the current user owns or has some privilege other than SELECT on.\r\n\r\nA possible answer is explained [here](https://stackoverflow.com/questions/39379939/how-to-access-information-schema-foreign-key-constraints-with-read-only-user-in)." ]

[]

[]

[ "I don't see any such regression: 06c283159fa9917fda8836e2b2973fd38da0a029" ]

[]

[]

[ "I gather you're using MySQL.\r\n\r\nFor what it's worth, the first example where `user_id` is `AutoField` -- the `info.user_id` stored in the database is still \"10\" in both cases. The reason \"0\" gets assigned, however, is because Peewee thinks this is an auto-increment integer field. So it is trying to read the new pk value from the cursor -- and since this is *not* actually an autoincrement field, this is returned as 0.\r\n\r\nYou can verify that the correct value is still stored in either case, however:\r\n\r\n```python\r\n###\r\n### Here UserInfo.user_id is an AutoField() instance.\r\n###\r\n\r\nIn [2]: u = UserInfo.create(user_id=10, name='bar') \r\n\r\nIn [3]: UserInfo.get().user_id \r\nOut[3]: 10\r\n\r\nIn [4]: u.user_id \r\nOut[4]: 0\r\n```\r\n\r\nIn this case, you should probably go back through the auto-generated code and change the `AutoField()` to `IntegerField(primary_key=True)` where applicable.", "You can see #2124 for some additional discussion.", "> You can see #2124 for some additional discussion.\r\n\r\nThanks." ]

[]

[]

[]

[]

[]

[ "As you can see from the traceback:\r\n\r\n```python\r\nFile \"/home/kyle/.local/lib/python3.7/site-packages/pymysql/cursors.py\", line 150, in mogrify\r\n query = query % self._escape_args(args, conn)\r\n```\r\n\r\nThe error is in pymysql, not peewee.", "No.\r\n\r\nThe error is not because of pymysql. It's because peewee incorrectly passes in the `params` parameter into `cursor.execute`.\r\n\r\nEven if it was, pymysql is not going to change their method, as stated in these issues [here](https://github.com/PyMySQL/PyMySQL/issues/562), [here](https://github.com/PyMySQL/PyMySQL/issues/507), and [here](https://github.com/PyMySQL/PyMySQL/issues/367). Seems easier just to correctly pass in the parameter.", "Just curious, why r u using pymysql?\r\n\r\nIMO mysql.connector works (and it has C extensions for better performance).", "No reason really. Never thought about it.\r\n\r\nI probably googled it at some point and picked the first thing that worked.", "Passing `params=None` does not work with psycopg2.", "Also I'd like to point out that the whole problem only arises because you are passing the parameters in literally, as part of the query, rather than using placeholders and a parameterized query. There are several reasons why this is bad: sql injection is the most obvious.", "Hm, well that's fair-ish. Really I brought it up because it seemed like other people were having trouble with it.\r\n\r\n> Passing `params=None` does not work with psycopg2.\r\n\r\nAnd as long as there's a reason for it, I'm satisfied. Hopefully laying out the issue will help people in the future." ]

[]

[]

[ "Your example code obviously won't run, as your classes do not extend `Model`. Neither can I tell why you are including a trailing \".\" after your CCC.select() and CCC.select().join(BBB).\r\n\r\nI just ran the following code without any issues on Python 3.8.0:\r\n\r\n```python\r\n\r\ndb = PostgresqlDatabase('peewee_test')\r\n\r\nclass BaseModel(Model):\r\n class Meta:\r\n database = db\r\n\r\nclass A(BaseModel):\r\n a = CharField(unique=True)\r\n\r\nclass B(BaseModel):\r\n a = CharField()\r\n b = ForeignKeyField(A)\r\n\r\nclass C(BaseModel):\r\n a = ForeignKeyField(A)\r\n b = ForeignKeyField(B)\r\n\r\ndb.create_tables([A, B, C])\r\na = A.create(a='1')\r\nb = B.create(a='2', b=a)\r\nC.create(a=a, b=b)\r\n\r\nlist(C.select())\r\nq1 = C.select().join(B)\r\nlist(q1)\r\nq2 = C.select().join(A)\r\nlist(q2)\r\ndb.drop_tables([A, B, C])\r\n```" ]

[]

[]

[ "Peewee doesn't convert types on assignment. It would convert the type before sending it to the database, e.g., if you used it in a query. But you can assign any value to any field type:\r\n\r\n```python\r\n\r\nIn [1]: from peewee import * \r\n\r\nIn [2]: class Foo(Model): \r\n ...: bar = IntegerField() \r\n ...: \r\n\r\nIn [3]: Foo.bar = 'hello' \r\n\r\nIn [4]: Foo.bar \r\nOut[4]: 'hello'\r\n```", "This bites hard when the application has to pass JSONs between DB and external sources. The \"custom field + `dict_to_model`\" combo becomes functionally useless in these cases.\r\n\r\nAny plans to alleviate this for custom fields?", "If you need data validation then I'd suggest using a dedicated (de)serialization layer between your database and whatever json you need to return. Or implement your own conversions.", "Not validation but just to have the right types coming out of the model in general.\n\nNot having that either makes the custom fields useless or leads to duplication of the conversions. Which also makes it impossible to achieve type-invariant code near the database, where that's really useful.\n\nI guess it's as simple as iterating over the fields and calling `python_value()` where needed, so not a big deal, but it's still a bit of a jarring omission.\n\nPR not necessary I suppose?", "FTR this is not about conversion on assignment, but the behavior of `dict_to_model`.", "Gotcha can you provide an example?", "@coleifer In our code, we use multiple custom fields that convert different enum and compound types to basic database types. We take them from their serialized JSON form - which, BTW, also uses basic types. I.e. there's a 1:1 mapping between the types of values we have in the resulting dict to the basic types that the DB uses.\r\n\r\nJSON —(`json.loads(...)`)→ `dict` — (`dict_to_model`)→ `Model`.\r\n\r\nAfter a bit of processing, the code sends out similar JSON to the next service in line.\r\n\r\n```\r\nfrom peewee import Field, Model\r\nfrom playhouse.shortcuts import dict_to_model\r\n\r\n\r\nclass MyFancyType:\r\n def __bool__(self): # Oversimplified for the sake of an example\r\n return True\r\n\r\n def do_something(self):\r\n return \"something\"\r\n\r\n\r\nclass FancyField(Field):\r\n field_type = \"BOOL\"\r\n\r\n def db_value(self, fancy):\r\n return bool(fancy)\r\n\r\n def python_value(self, value):\r\n return MyFancyType()\r\n\r\n\r\nclass MyModel(Model):\r\n ...\r\n something_fancy = FancyField()\r\n\r\n\r\nm = dict_to_model(MyModel, {\"something_fancy\": True})\r\nm.something_fancy.do_something() # ⊥ - AttributeError: 'bool' object has no attribute 'do_something'\r\n```\r\n\r\nEven if `peewee` does not convert between types on assignment (which I agree with), it would be nice to have `dict_to_model` and `model_to_dict` versions that assume operation on `db_value()` kinds of values.\r\n\r\nCurrent versions imply usage of `python_value` kind, which means that the conversion code from the fields has to be duplicated and applied separately for `dict_to_model` input, negating the value of customs.\r\n\r\nAlmost all basic db types have 1:1 correspondance with Python's basic types. This would make serializing the model with custom fields a breeze.", "@coleifer any comments on this? Should I create a new issue / send PRs?", "Doesn't this all boil down to:\r\n\r\n>Peewee doesn't convert types on assignment.\r\n\r\nThe helpers in `shortcuts` (the module name should provide the clue) are just shortcuts. If you want some special behavior, I suggest implementing it yourself in your own module.\r\n\r\nYou can always iterate your fields after assignment, calling each field's `python_value()`. This is trivial:\r\n\r\n```python\r\ndef my_dict_to_model(M, data):\r\n m = dict_to_model(M, data)\r\n for field in M._meta.sorted_fields:\r\n setattr(m, f.name, f.python_value(getattr(m, f.name)))\r\n return m\r\n```", "> Doesn't this all boil down to: Peewee doesn't convert types on assignment.\r\n\r\nI don't see why this has to be the case for shortcut functions. The model doesn't convert, but why should the shortcuts be limited this way? If this makes it difficult to serialize custom fields - why not just introduce an alternative shortcut that helps with this?\r\n\r\nI certainly don't like the idea of rummaging in model internals just to get that to work, but this is what I use for this now.\r\n\r\nIt just seems like a very odd gap in the user story: Peewee has custom fields, but the shortcuts \"do not care\" about them in any way - so you might as well not use custom fields if you want to use the shortcuts." ]

[]

[]

[ "\r\n", "Peewee requires that you be explicit w/the decimal field. If you dislike this functionality, then you can subclass it and override the `get_modifiers()` method.\r\n\r\n```python\r\n\r\nclass NumericField(DecimalField):\r\n def get_modifiers(self):\r\n pass\r\n```" ]

[]

[]

[ "The way to do this with Peewee 3 is probably to use the various context-managers:\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/api.html#Database.bind_ctx\r\n\r\nYou can explicitly set `Query._database` as well on a one-off basis, but that's up to you.", "Yep, I went with `DB.bind(models)`. Thanks for the response.", "@aniljaiswal \r\nStumbled upon this issue while looking for read slaves in peewee. \r\nmay i do not completely comprehend how to use the context manager in here\r\nHow does `DB.bind(models)` work if you want to use the same model for both read and write operations, where my reads are executed on slaves and write on master ?", "You basically create two connections, one for read and other for write. For read connection, you can specify the models to bind to the database.", "Got it. Thanks" ]

[]

[]

[ "Transaction management is left up to the user. So if you want atomicity, then wrap your operations in the `atomic()` context manager.\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/database.html#managing-transactions", "Thanks for the answer" ]

[]

[]

[ "https://www.postgresql.org/docs/9.3/functions-array.html#ARRAY-FUNCTIONS-TABLE", "The issue tracker is not for \"how do I...\" questions. Ask those on:\r\n\r\n* StackOverflow\r\n* IRC\r\n* Mailing list\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/contributing.html#questions" ]

[]

[]

[ "Read the postgresql array docs: https://www.postgresql.org/docs/9.1/arrays.html\r\n\r\nYou can use the concatenation operator, though it's pretty \"fragile\" and may complain about operators, in which case you'll need to use casts." ]

[]

[]

[ "Peewee introduced an efficiency measure in `bulk_create()` to use the object-id descriptor to grab the associated PK of the related object. It seems it has had an unintended side-effect of not reflecting the new primary-key value upon saving the related object. I'll look into this.", "Fixed. Note that this would only have worked with postgres, thanks to postgres' ability to return autogenerated IDs after a bulk insert query. So this is kinda under \"yeah, it works, but it's a little weird\" category.\r\n\r\nAt any rate it should be working again on master. I've added a regression test which reproduced the issue and now passes.", "Thanks for the quick turnaround! I tried it out in the example I put together and everything seems to be working." ]

[]

[]

[ "I'd be happy to look into this, but I'm not digging through all the craziness.\r\n\r\nIf you can produce a *minimal* example using simple models (e.g. my favorites are \"User\" / \"Tweet\") I'll reopen and investigate." ]

[]

[]

[ "Peewee does not add comments to the schema.", "Is this functionality you would be interested in having as part of peewee? \r\n\r\nI already have code I could easily adapt to a PR.\r\n\r\n@pch18 A solution for you could look something like this:\r\n``` python\r\nimport peewee as pw\r\n\r\n\r\nclass DatabaseComment(pw.Node):\r\n def __init__(self, obj, comment, obj_type):\r\n self.obj = obj\r\n self.comment = comment\r\n self.obj_type = obj_type\r\n\r\n def __sql__(self, ctx):\r\n ctx.literal('COMMENT ON ')\r\n ctx.literal(self.obj_type)\r\n ctx.literal(' ')\r\n with ctx.scope_values():\r\n if isinstance(self.obj, pw.Field):\r\n ctx.sql(self.obj.model).literal('.')\r\n ctx.sql(self.obj)\r\n\r\n ctx.literal(' IS ')\r\n ctx.sql(self.comment)\r\n return ctx\r\n\r\n \r\n# >>> datababase.execute(DatabaseComment(SomeTable, 'Hello world', 'TABLE'))\r\n```" ]

[]

[]

[ "The issue is the final `select()` method.\r\n\r\n```python\r\n\r\nq1 = Data.select()\r\nq2 = Data.select()\r\nquery = q1.union(q2)\r\n```", "I probably wasn't explaining the issue well enough, but focused on giving a minimal example to reproduce the issue.\r\n\r\nWhat I have are two different queries producing two different tables. I then select from the union of these tables, and do some calculations in the select statement. It looks something like this:\r\n\r\n```python\r\ncomplex_query1 = ...\r\ncomplex_query2 = ...\r\ncomplex_query1.union(complex_query2).select(\r\n # Do calculations here based on this union\r\n)\r\n```\r\nI want to be able to select from this union, as it allows me to do the calculations in a nice way. I know there are workarounds, but would be more clean to do something like this.", "Then use the `select_from()` API instead." ]