Datasets:

---

akumoth

/

peewee-issues

like 0

[]

[]

[ "> Values that exceed length are not truncated automatically.\r\n\r\nAs that says, values that exceed length **are not truncated**.\r\n\r\nI'd suggest that you should familiarize yourself with the database you're using, sqlite in this case: https://sqlite.org/datatype3.html\r\n\r\nSqlite has the following data-types:\r\n\r\n* text\r\n* blob\r\n* integer\r\n* real (float)\r\n* null\r\n\r\nCreating a `*char*` column will use the `text` data-type, but there is no validation of max-lengths or anything. You can create an explicit constraint, but the default behavior is just to treat it as text.", "That is a great suggestion. I went ahead and made assumptions I shouldn't have made. Thank you for the tips.\r\n\r\nFor reference, taken from the [SQLite documentation about quirks](https://sqlite.org/quirks.html#flexible_typing):\r\n> [...] SQLite allows you to store a 2000-character string into a column of type VARCHAR(50). Other SQL implementions would either throw an error or truncate the string. SQLite stores the entire 2000-character string with no loss of information and without complaint. [...]" ]

[]

[]

[ "See 04aa7a0 for the fix.", "Is this planned to a 3.8.1 release? The fix was really fast, thanks.", "I'll release this fix along with 3.8.1 at some point in the coming days/weeks.\r\n\r\nIn the meantime there are a number of workarounds. The simplest being instead of using `.get()` with keyword arguments, use expressions, e.g.: `MyModel.foo == 'bar'` is *always* preferable to `foo='bar'`." ]

[]

[]

[ "Read the docs: http://docs.peewee-orm.com/en/latest/peewee/relationships.html#manytomany\r\n\r\nAnd: http://docs.peewee-orm.com/en/latest/peewee/relationships.html#manytomanyfield", "I read the docs many times, but i still did not find what am i doing bad?" ]

[]

[]

[ "As a temporary workaround, try using the actual field objects instead of the field-names as strings, e.g.:\r\n\r\n```python\r\nrecord = {\r\n Session.someid: 'textid',\r\n Session.tstp: datetime.datetime(2018, 12, 12),\r\n Session.data: {},\r\n}\r\n```", "Fixed by f59ee6d" ]

[]

[]

[ "Only 2x is really not as bad as I might have thought.\r\n\r\nYes, it's because peewee contains logic for converting python data-types to data-types that can be handled by the database. For example, if you're using `TimestampField` you work with `datetime` objects in Python code, but when it comes to interacting with the DB we convert this to an integer. So when you are inserting objects, peewee is efficient, but it still must make sure to apply all conversions to the application data before sending it to the db. Same applies when reading from a cursor.\r\n\r\nThe code in peewee is optimized and uses efficient algorithms, but its doing a lot for you to make life easier and there's a performance cost.\r\n\r\nAt the end of the day remember that it's python. It's slow compared to C. You want to go fast? Use C.", "Thanks for the reply. For anyone else who stumbles on this. I was able to get similar performance as sqlite's executemany using using peewee's execute_sql like this. Not ideal, but is worth it for me because of large inserts i need to do and since this table has pretty simple data types. \r\n\r\nI like to use peewee for the other nice features like datetime you mentioned.\r\n\r\n``` python\r\ninsert_query = ''' INSERT OR IGNORE INTO foo_table (seq, params_in, results_out) VALUES (?, ?, ?) '''\r\nwith db.atomic():\r\n for row in to_insert:\r\n db.execute_sql(insert_query, row)\r\n```\r\n\r\n", "For select queries, when you are iterating over lots of rows, here are some docs that may be helpful:\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/querying.html#iterating-over-large-result-sets", "There's also [sweepea](https://github.com/coleifer/sweepea), a sqlite query-builder I wrote using Cython that may be faster." ]

[]

[]

[ "Thnx." ]

[]

[]

[ "Thanks for the report, I will look into it.", "I would like to contribute in a solution as well, but it's hard to understand how the project is structured. Do you have any tips for where to begin?", "The code's only a few thousand lines, definitely readable in one sitting. You can ignore everything except `peewee.py` for getting started." ]

[]

[]

[ "+ add `micawber` dependency", "thx, updated." ]

[]

[]

[ "Read the docs:\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/query_operators.html\r\n" ]

[]

[]

[ "Ahh, yeah, `count()` appears not to be taking into consideration the fact that the query has a CTE. This is a usage I hadn't considered.\r\n\r\nI'd suggest just modifying your own SQL in the meantime as a workaround, e.g., to get the count, just write a query that looks like `.select(fn.COUNT(...))`.", "Thanks for the suggestion, but I first noticed this when using `from playhouse.flask_utils import PaginatedQuery` which seems to use `.count()` internally. Should I just change the source of that file to use this `.select(fn.COUNT(...))` method?", "Ehh, or you could subclass `PaginatedQuery` and override the `get_page_count()` method? ", "I ended up re-writing the query to not use CTEs. Do you have any interest in fixing CTEs with `count()`?", "I'm leaving the issue open for now as I believe there's a bug here. I just haven't figured out yet how to address it.", "A similar issue is reported by @iksteen in #1838.\r\n\r\nSince these are closely related, I'm including the issue description here:\r\n\r\n----------------------------------------------------------------\r\n\r\nConsider the following example (note that this is obviously a silly example, but just enough to show the problem):\r\n```\r\nfrom peewee import *\r\ndb = PostgresqlDatabase('scoreboard')\r\n\r\nclass Base(Model):\r\n class Meta:\r\n database = db\r\n\r\nclass Challenge(Base):\r\n pass\r\n\r\nclass Attachment(Base):\r\n challenge = ForeignKeyField(Challenge, backref='attachments')\r\n\r\ncte = (\r\n Challenge\r\n .select(fn.MAX(Challenge.id).alias('max_id'))\r\n .cte('demo')\r\n)\r\n\r\nq = (\r\n Challenge\r\n .select(Challenge)\r\n .join(cte, on=(Challenge.id == cte.c.min_id))\r\n .with_cte(cte)\r\n)\r\np = Attachment.select()\r\nr = prefetch(q, p)\r\nprint(list(r))\r\n```\r\n\r\nThe generated SQL for the prefetch of Attachment will be:\r\n```\r\nSELECT \"t1\".\"id\", \"t1\".\"challenge_id\" FROM \"attachment\" AS \"t1\"\r\nWHERE (\r\n \"t1\".\"challenge_id\" IN\r\n WITH \"demo\" AS ((SELECT MAX(\"t2\".\"id\") AS \"min_id\" FROM \"challenge\" AS \"t2\"))\r\n (SELECT \"t3\".\"id\" FROM \"challenge\" AS \"t3\" INNER JOIN \"demo\" ON (\"t3\".\"id\" = \"demo\".\"min_id\"))\r\n)\r\n```\r\n\r\nWhile the CTE queries and the subquery themselves do get extra parentheses, the base query is not parenthesized leaving the `WITH` part bare and resulting in an invalid syntax.\r\n\r\nThe expected query would be:\r\n```\r\nSELECT \"t1\".\"id\", \"t1\".\"challenge_id\" FROM \"attachment\" AS \"t1\"\r\nWHERE (\r\n \"t1\".\"challenge_id\" IN (\r\n WITH \"demo\" AS (SELECT MAX(\"t2\".\"id\") AS \"min_id\" FROM \"challenge\" AS \"t2\")\r\n SELECT \"t3\".\"id\" FROM \"challenge\" AS \"t3\" INNER JOIN \"demo\" ON (\"t3\".\"id\" = \"demo\".\"min_id\"))\r\n )\r\n)\r\n```\r\n", "Thanks to @iksteen for his fix in #1839. This is now resolved.", "Thanks @coleifer and @iksteen!" ]

[]

[]

[ "Oh, I should have mentioned, I'm using SQLite.", "Ahh, yeah, its these lines that are causing the issue:\r\n\r\nhttps://github.com/coleifer/peewee/blob/3634aea5ece71e21a2ac5cdb2b74b194e8257960/playhouse/migrate.py#L682-L685", "It appears that if I rename my 'primaryName' column, the problem goes away (as long as the new name doesn't start with 'primary' (or 'foreign')).\r\n\r\nI suppose I could do that, but of course it will be a PITA.\r\n\r\nFor now, I implemented raw ALTER TABLEs as necessary. I'll have to think this over and figure out if it's worth renaming the column.\r\n", "Fixed in 1e00d33" ]

[]

[]

[ "Not sure if it's the correct solution but it seems that making\r\n\r\n```python\r\n return (ManyToManyQuery(instance, self, self.rel_model)\r\n .join(self.through_model)\r\n .join(self.model)\r\n .where(self.src_fk == getattr(instance, self.src_fk.rel_field.name)))\r\n```\r\n\r\nin `ManyToManyFieldAccessor` fixes the problem.", "As you noted, the issue is that the field \"designation\" on `TwoMassPsc` is not the primary key:\r\n\r\n```python\r\n tmass_source = ForeignKeyField(TwoMassPsc,\r\n column_name='original_ext_source_id',\r\n field='designation',\r\n backref='gaia_best_neighbour')\r\n```\r\n\r\nI'll repeat the strong admonition from the documentation here, just in case someone comes across this in the future:\r\n\r\n> Peewee provides a field for representing many-to-many relationships, much like Django does. This feature was added due to many requests from users, but I strongly advocate against using it, since it conflates the idea of a field with a junction table and *hidden joins*. It’s just a nasty hack to provide convenient accessors.\r\n\r\nThe emphasis (added) is that for all but the simplest use-cases, you're going to have a better time just using a junction model.\r\n\r\nAgain, I do think that this is a legit bug and I will patch it, but I'd suggest that unless you're doing very basic/plain many-to-many queries, you should always prefer the explicit junction table." ]

[]

[]

[ "As you noticed, there's no such thing as a `DeferredManyToManyField`, nor do I think there needs to be. Remember that a many-to-many is just a junction table with foreign-keys to the table(s) being related via many-to-many. To use my favorite example,\r\n\r\n```python\r\n\r\nclass Student(Model):\r\n name = TextField()\r\n # courses = ManyToManyField(Course) ??? there's no need to do this.\r\n\r\nclass Course(Model):\r\n name = TextField()\r\n students = ManyToManyField(Student) # do this instead. many-to-many is symmetrical.\r\n\r\n# Or, better yet, don't use ManyToManyField at all and just:\r\nclass CourseStudent(Model):\r\n course = ForeignKeyField(Course)\r\n student = ForeignKeyField(Student)\r\n```\r\n\r\n> I wonder if it'd possible to add a `through_model` keyword to both `ForeignKeyField` and `DeferredForeignKey` which, if set, would make the foreign key behave as a `ManyToManyField`.\r\n\r\nZen of Python:\r\n\r\n> Special cases aren't special enough to break the rules.\r\n> ...\r\n> There should be one-- and preferably only one --obvious way to do it. " ]

[]

[]

[ "From the [documentation](http://docs.peewee-orm.com/en/latest/peewee/relationships.html#manytomany):\r\n\r\n> Peewee provides a field for representing many-to-many relationships, much like Django does. This feature was added due to many requests from users, but I strongly advocate against using it, since it conflates the idea of a field with a junction table and hidden joins. It’s just a nasty hack to provide convenient accessors.\r\n\r\nRegarding the backref ... I'm not sure I completely understand, but it appears to me that disabling the backref on the ManyToManyField works correctly:\r\n\r\n```python\r\nclass Student(Model):\r\n name = TextField()\r\n\r\nclass Course(Model):\r\n name = TextField()\r\n students = ManyToManyField(Student, backref='+')\r\n\r\nCourseStudent = Course.students.get_through_model()\r\n\r\n# ...\r\n# It seems to work fine to use the `course.students` many-to-many accessor:\r\nmath = Course.create(name='math')\r\ns = Student.create(name='s')\r\nmath.students.add(s) # Works.\r\nlist(math.students) # Works, returns [<Student: 1>]\r\n```\r\n\r\nAnd, as it would suggest, there is no backref on the `Student` model, e.g. there's no `student.courses` backref.\r\n\r\n-------------------------\r\n\r\nIf you're talking about manually declaring a through-model with backrefs disabled on both sides...I have to ask: what are you even bothering with using `ManyToManyField` for?\r\n\r\nI'm not saying there's not a bug in the code. I am, however, suggesting that you're making a foolish choice to try and use ManyToManyField for anything but the most trivial many-to-many implementations." ]

[]

[]

[ "What's the actual error? \"ValuesList has no attribute source\"?\r\n\r\nedit: nevermind, replicated \"AttributeError: 'ValuesList' object has no attribute '_hash'\"" ]

[]

[]

[ "My own sense is that this is a niche usage and not widely supported.\r\n\r\nRather than implement a special-case for this, I'll suggest using `NodeList` and `SQL` to compose the appropriate \"ORDER BY\" clause.", "Could you give an example on how to use NodeList with `fn`? Because for me:\r\n+ `fn` wraps its arguments with parens and,\r\n+ I couldn't figure out how to put `NodeList` as `fn` argument. ", "```sql\r\nSELECT array_agg(\r\n \"t1\".\"name\" ORDER BY \"t1\".\"name\" ASC, \"t1\".\"created_at\" DESC\r\n) AS \"users\" \r\n```\r\n\r\n```python\r\nname_asc = NodeList((User.name, SQL('ORDER BY'), User.name.asc()))\r\n...select(fn.array_agg(name_asc, User.created_at.desc()).alias('users'))\r\n```", "That's much harder to look at. Guess I just have to maintain a subclass in my code.\r\n\r\nBy the way, what do you think are the cons of supporting this in `fn`?" ]

[]

[]

[ "the question has been asked in stackoverflow : [link](https://stackoverflow.com/questions/28514736/how-to-select-a-random-row-with-a-group-by-clause) ,but i don't know how to translate it to peewee. please help me...\r\ni am stuck in there for a long time.\r\n", "It can be done like this:\r\n\r\n```python\r\nobjects_tbl = Table('objects')\r\nimages_tbl = Table('images')\r\nsubquery = (objects_tbl\r\n .select(images_tbl.c.image_path,\r\n objects_tbl.c.id.alias('object_id'),\r\n objects_tbl.c.name)\r\n .order_by(SQL('RAND()'))\r\n .join(images_tbl, join_type=JOIN.LEFT_OUTER, on=images_tbl.c.object_id == objects_tbl.c.id)\r\n .alias('z'))\r\nquery = (Select().select(subquery.c.object_id, subquery.c.name,\r\n subquery.c.image_path)\r\n .from_(subquery)\r\n .group_by(subquery.c.object_id, subquery.c.name))\r\n```\r\n\r\nOutput:\r\n```SQL\r\n--- query.sql()\r\nSELECT \"z\".\"object_id\", \"z\".\"name\", \"z\".\"image_path\" \r\nFROM (\r\n SELECT \"t1\".\"image_path\", \"t2\".\"id\" AS \"object_id\", \"t2\".\"name\" \r\n FROM \"objects\" AS \"t2\" \r\n LEFT OUTER JOIN \"images\" AS \"t1\" ON (\"t1\".\"object_id\" = \"t2\".\"id\") \r\n ORDER BY RAND()\r\n) AS \"z\" GROUP BY \"z\".\"object_id\", \"z\".\"name\"\r\n```", "yeah, thank you very much, i solved the problem about 30 mininutes ago。 I found the answer in [charlesleifer.com/blog](http://charlesleifer.com/blog/querying-the-top-n-objects-per-group-with-peewee-orm/)\r\nmy code is this:\r\n\r\n```\r\n random_query = (\r\n Sentence.select(Sentence, Level.difficulty)\r\n .join(Level, on=(Sentence.level_id == Level.id))\r\n .order_by(pw.fn.Rand())\r\n .where(\r\n Sentence.status == ResourceStatus.PUBLISHED,\r\n Level.status == ResourceStatus.PUBLISHED,\r\n )\r\n )\r\n sentences = (\r\n Sentence.select(\r\n random_query.c.status,\r\n random_query.c.content,\r\n random_query.c.id,\r\n random_query.c.level_id,\r\n )\r\n .from_(random_query)\r\n .group_by(random_query.c.difficulty)\r\n )\r\n```\r\n\r\nthank you very much~\r\n\r\n\r\n", "That's great. Then we should also close the issue.", "Good stuff, yep that example looks good." ]

[]

[]

[ "Hmm, it seems that if I use `CompoundSelectQuery` (which isn't imported using `from peewee import *`), it does work.\r\n\r\nIs that the intended way to solve the problem?\r\n\r\nEdit: I guess not, because trying to use a correlated subquery will create a new alias for the original table,", "Is there a situation possible where either side of an expression can be aliased? I personally can't think of any, and if that is a correct assumption, the `in_op` context variable introduced by the fix for #1716 could be extended to include all operations (and `in_op` could be renamed to `in_expr`).", "You might notice that some operands will appear to work when the right-hand-side is a query object, but others will not work if the query is on the left-hand-side. This is because queries are not treated as column-like objects (even though in your example you are using a query as a column-like value). Furthermore in some cases attempting to use a query on the left-hand-side will result in the generation of JOIN clauses, since table-like objects (such as queries) implement operator overloads for representing JOINs...e.g. query1 + query2 == query1 UNION ALL query2.\r\n\r\nIts not quite clear to me that creating a correlated subquery is the issue, as I've added test-cases showing that its possible: e321a23be4ac9c5bb42af9e460a980ef5e408214\r\n\r\nThe problem seems to arise when attempting to use a correlated subquery in an expression... Could you achieve what you're attempting by just using a join and aggregate instead?", "Original:\r\n```python\r\ndecayed_score = Challenge.select(\r\n Challenge.points / Team.select(fn.count(Team.id) + 1)\r\n)\r\n```\r\n\r\nAlternative:\r\n\r\n```python\r\nquery = Challenge.select(Challenge.points / fn.COUNT(Team.id) + 1).join(Team, JOIN.LEFT_OUTER).group_by(...)\r\n```", "Ah right, unions could have an alias.\n\nAnd yes, in this small example the aggregation that would work.. but it wouldn't fit my monster query (which I'm too afraid and ashamed to show).\n\nHowever, by you having me rethink my method, you put me on a path where I think I can rewrite that monster query using CTEs where I won't wouldn't run into this issue.\n\nThat makes the issue not invalid, but feel free to close it anyway.", "Think this is now resolved: fb41bfcbc68b87ab315dfbf8a2c935a4b3eda1c8", ":+1: That's exactly the way I got it to work locally (well, minus the parentheses rework).\r\n\r\nBetween you and me, this is my query now (please don't hate me): https://plak.infrapuin.nl/0bnaddnw.py This new commit allows me to get rid of the `team_count` cte." ]

[]

[]

[ "Closing as a roughly equivalent patch was merged instead." ]

[]

[]

[ "In some databases people don't use actual foreign-key constraints, especially SQLite and MySQL. Additionally, introspecting a column named \"foo_id\", regardless of whether or not its a foreign-key, I think it's a reasonable assumption that we assume the Pythonic name should be \"foo\".\r\n\r\nThat being said, there's also the case of an externally-managed ID. Say you're caching some response data from a 3rd-party API and want to store a user_id that has no reference to anything else in your DB. In that case it seems reasonable to retain the \"user_id\" column name and that calling it \"user\" would actually be somewhat misleading.\r\n\r\nAfter giving it some thought, I think I agree with you that this logic should only apply in the case of foreign-keys.", "Merged a patch that is similar to #1800 but with the following differences:\r\n\r\n* is_foreign_key=False by default (yours has =True)\r\n* has tests \r\n* not O(n) on each column (!!)" ]

[]

[]

[ "I'd typically think it would be better to use UTF8 when creating the database, e.g.:\r\n\r\n```sql\r\nCREATE DATABASE foobar CHARACTER SET utf8 COLLATE utf8_unicode_ci;\r\n```\r\n\r\nI understand the storage concerns, though. You should be able to add the charset as peewee supports arbitrary constraints:\r\n\r\n```python\r\nfield = CharField(constraints=[SQL('CHARACTER SET utf8 COLLATE utf8_unicode_ci')])\r\n```", "First, thanks for the suggestion.\r\n\r\nI tried to apply the next definition:\r\n```python\r\nname = CharField(unique=True, constraints=[SQL('CHARACTER SET utf8 COLLATE utf8_unicode_ci')])\r\n```\r\n\r\nBut there was an SQL syntax error due the generated SQL , that was something similar to:\r\n\r\n```SQL\r\nCREATE TABLE foo (field VARCHAR(255) NOT NULL CHARACTER SET utf8 COLLATE utf8_unicode_ci);\r\n```\r\n\r\nThe problem comes from the `NOT NULL` which was put before of `CHARACTER SET`. To solve this was necessary to set `NOT NULL` after of charset declaration, in this way:\r\n\r\n```SQL\r\nCREATE TABLE foo (field VARCHAR(255) CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL);\r\n```\r\n\r\nTo achieve the previous sentence from peewee I had to write the next declaration, which it is a bit tricky:\r\n\r\n```python\r\nfield = CharField(unique=True, null=True, constraints=[SQL('CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL')])\r\n```\r\n\r\nSo even if it is possible to reach the desire SQL statement this problem should be revised since my solution is just an ugly hack.\r\n", "I just realize that `CHARACTER SET` is not available in SQLite, therefore if you put that in constraints parameter the table creation fails in SQLite (due to the generated SQL statement). Thus this is not a valid solution because don't allow to use both SQLite and Mysql in a transparent way. \r\n\r\nI encourage to solve this problem cause I believe that peewee it's a nice tool with a really nice interface, but this kind of issue could make them unusable in several cases.\r\n", "No, I'm pretty sure this is just a MySQL thing. In postgres you set the encoding on the database. Sqlite is just utf8, as far as I know.\r\n\r\nTypically I think its unusual to specify the charset on just a single column. Usually one would set a default charset on the database or maybe(?) the table." ]

[]

[]

[ "Peewee contains code that correctly truncates long index names. I've added a new patch that truncates long foreign-key constraint names, which will be included in the next release.\r\n\r\nYou're using an ancient version, I suggest upgrading." ]

[]

[]

[ "Nice catch, thanks." ]

[]

[]

[ "Thanks, nice catch. Merged your patch." ]

[]

[]

[ "At present Peewee's schema manager does not have support for views.\r\n\r\nJust write out the SQL. In the time you took to type up your issue, and for me to respond, surely you could have typed out the SQL?\r\n\r\nIf you insist, you can implement a custom query component.\r\n\r\nHere's a complete example:\r\n\r\n```python\r\n\r\nfrom peewee import *\r\nfrom peewee import ColumnBase\r\n\r\nclass AsIsValue(ColumnBase):\r\n def __init__(self, value):\r\n self._value = value\r\n super(AsIsValue, self).__init__()\r\n\r\n def __sql__(self, ctx):\r\n if isinstance(self._value, str):\r\n # Ensure strings are quoted.\r\n value = \"'%s'\" % self._value\r\n elif self._value in (True, False):\r\n # Convert boolean to integers.\r\n value = 1 if self._value else 0\r\n elif self._value is None:\r\n value = 'NULL'\r\n return ctx.literal(str(value))\r\n\r\ndb = SqliteDatabase(':memory:')\r\n\r\nclass User(Model):\r\n username = TextField()\r\n is_admin = BooleanField(default=False)\r\n class Meta:\r\n database = db\r\n\r\ndb.create_tables([User])\r\n\r\nfor username, admin in [('huey', True), ('mickey', False), ('zaizee', True)]:\r\n User.create(username=username, is_admin=admin)\r\n\r\nadmin = (User\r\n .select()\r\n .where(User.is_admin == AsIsValue(True))\r\n .order_by(User.username))\r\n\r\nview_sql = 'CREATE VIEW \"user_admin\" AS %s' % admin.sql()[0]\r\ndb.execute_sql(view_sql)\r\n\r\nAdmin = Table('user_admin', ('id', 'username', 'is_admin'))\r\nfor obj in Admin.select().execute(db):\r\n print(obj['username'])\r\n```\r\n\r\nNow...which is easier? Up to you.", "I did something like this and it works like a charm. I am Not sure it is elegant \r\n\r\n\r\n```python\r\nclass Variant(Model):\r\n\tclass Meta:\r\n\t\tdatabase = db \r\n\r\n\t@classmethod\r\n\tdef create_view(cls,name, where_clause):\r\n\t\tsql = Variant.select().where(where_clause).sql()\r\n\r\n\t\t# replace parameters in raw sql \r\n\t\traw = sql[0]\r\n\t\tparams = sql[1] \r\n\r\n\t\tfor param in params:\r\n # quote params \r\n\t\t\tparam = f\"'{param}'\"\r\n\t\t\traw = raw.replace(\"?\", param, 1) \r\n\r\n\t\tVariant._meta.database.obj.execute_sql(f\"CREATE VIEW {name} AS {raw}\")\r\n\t\t# Create a class dynamically\r\n\t\tclass VariantView(cls):\r\n\t\t\tclass Meta:\r\n\t\t\t\tdb_table = name\r\n\r\n\t\treturn VariantView\r\n\r\nVariant.select().count() // return 590\r\n\r\nMyView = Variant.create_view(\"my_view\", Variant.pos > 432234 ) \r\nMyView.select().count() // return 121 \r\n\r\n\r\n```", "The use of formatting strings is just vomit, in my opinion...yuck. Whatever works man. I'm glad I'm not maintaining that mess, though." ]

[]

[]

[ "I believe the relevant changes are here: ecfa98c9f2d5d6b30f238d97928662d909f769e2\r\n\r\nAlthough I would point out that changing the above to \"raw_node\" does not affect the outcome of the query in any case. Change the line and try it for yourself -- the value is still an int.\r\n\r\nThere is no connection, internally, between `tmp.c.id` and either `Products.id` or `Products.id.cast('text')`. Dynamic column references such as `tmp.c.id` bear no relation to any field, and the heuristic simply looks at the column names to try and determine if a dynamic column lines up with a field.\r\n\r\nThe way to handle this correctly is:\r\n\r\n```python\r\nProducts.select(tmp.c.id.coerce(False)).with_cte(tmp).from_(tmp)\r\n```\r\n\r\nAnd in fact, without the change you referred to (`node._coerce` vs `raw_node._coerce`) this logic would not work.\r\n\r\nSo the code is correct, in my opinion. See this test for details: 0d2e81b873c6ac6fe968779c3bf18af06f5a6a47", "Thanks for clarifying. Though I should say that it might be a breaking change, because it breaks my code after upgrade to newer Peewee. May be a note in CHANGELOG?", "> because it breaks my code after upgrade to newer Peewee\r\n\r\nAre you sure?", "Yes. It is one of our company's project and upgrading peewee to master (we also had another problem that was also fixed in master), our CI just broke all over the place that I had a hard time to debug it. Probably because we make use of CTE a lot.\r\n\r\nBut indeed, changing our code to what you suggested works so it's ok for us now. ", "Gotcha gotcha -- I think I was confused because when testing locally, changing `node` to `raw_node` did not have any effect in the example you provided. However, there are some other reorganizations of that code that may be causing the discrepancies you're seeing.\r\n\r\nAt any rate, using the `.coerce(False)` ought to take care of it. Thanks for your comments and contributions -- it's nice to work w/someone who has a solid understanding of how peewee works." ]

[]

[]

[ "I chose to implement this a bit differently -- the result is equivalent for your test-case, however. Rather than checking the rhs inside expression, I thought it made sense to simply not apply a conversion to the arguments of a function at all.\r\n\r\n178bc0155bf569c9245296e90ba5066901e208bc" ]

[]

[]

[ "Thanks for this, and for the patch. I chose to implement the fix a bit differently than your suggested fix, but they should be equivalent. The solution I merged is more general, and avoids applying conversion to function arguments in any case.\r\n\r\n178bc0155bf569c9245296e90ba5066901e208bc", "Thanks. I also did think that this should be put somewhere else better. \r\n\r\nP/S. How could you keep being responsive to every issues all the time like this? (No need to answer, just me admiring you). " ]

[]

[]

[ "I'm not pursuing it, nor am I in a position to recommend an alternative.", "I ported @insolite’s [graphene-peewee-async](https://github.com/insolite/graphene-peewee-async) to the regular Peewee. Check it out here:\r\n\r\n[graphene-peewee](https://github.com/emperorplatform/graphene-peewee)\r\n\r\nThis is my first major OSS contribution, so please leave feedback if anything can be improved. Also, this is an early release with limited testing. It has not been used in production by me. There may well be bugs." ]

[]

[]

[ "The logger statements are intended to log the tuple. Interpolation/parameterization wouldn't work, anyways, as not all databases necessarily use \"%s\" to signify parameters...sqlite uses \"?\" for instance. The idea is that we log both the SQL and the params as a tuple rather than trying to interpolate.", "I understand that\r\n('SELECT c FROM t WHERE d > ?', [3])\r\nis more preferable than\r\n('SELECT c FROM t WHERE d > 3')\r\nand more correct. I am not saying you can or should interpolate, probably you cannot, or that arguments should not be logged, they should be.\r\n\r\nWhat I am saying is that nobody ever expects LogRecord.msg to be anything but string. All log files are screwed.", "> What I am saying is that nobody ever expects LogRecord.msg to be anything but string. All log files are screwed.\r\n\r\nYou have to explicitly enable logging for peewee, and even then, at the DEBUG level. If you are trying to log peewee at the debug level, presumably you know what you're doing." ]

[]

[]

[ "Going to pass." ]

[]

[]

[ "Schemas, in SQLite, refer to attached databases. Therefore, to use \"schemas\" in SQLite you will need to attach databases with the given names. This is an advanced usage and probably not what you want, so I recommend avoiding the use of schema with sqlite unless you know what you're doing.", "Thanks for the quick answer!\r\n\r\nI'm really only using SQLite to simulate my production environment (postgres) as close as possible during testing. In my production database tables are scattered through several schema (however my flask app only uses one). \r\n\r\nIf you say it's not possible to just replace the database driver and use it like that while testing I can live with that but I think it would be nice if the documentation would reflect this limitation. " ]

[]

[]

[ "Merged equivalent patch." ]

[]

[]

[ "Nice, thanks.", "You response speed in incredible! Thank you!\r\n\r\nCan you please clarify why you have \"not in '!+'\" in one place and \"== '+'\" in another place?\r\nAre not backref='+' and backref='!' the same?", "Sorry for the lack of documentation on this... \"!\" is retained for backwards-compatibility but should not be used. At some point I will remove that and just use `== '+'`." ]

[]

[]

[ "There is no \"exclude_autogenerated\" option. You can, however, use the \"exclude\" option to specify the foreign-key of the backref you wish to exclude." ]

[]

[]

[ "That information is outdated and was likely removed when 3.0 was released... I don't see any references to that from within Peewee.\r\n\r\nFor multiprocess, just be sure not to connect until after the fork." ]

[]

[]

[ "`fields` is not something you assign, it is inferred from the fields declared on the model. It is a metadata attribute and should be considered read-only." ]

[]

[]

[ "I see -- good work on finding a workaround.\r\n\r\nLooks to me like a bug. Peewee is being too aggressive about stripping out the selected columns. The logic in the code reads:\r\n\r\n```python\r\n clone = self.order_by().alias('_wrapped')\r\n if clear_limit:\r\n clone._limit = clone._offset = None\r\n try:\r\n if clone._having is None and clone._windows is None and \\\r\n clone._distinct is None and clone._simple_distinct is not True:\r\n clone = clone.select(SQL('1'))\r\n except AttributeError:\r\n pass\r\n return Select([clone], [fn.COUNT(SQL('1'))]).scalar(database)\r\n```\r\n\r\nProbably out to be:\r\n\r\n```python\r\nif clone._having is None and clone._windows is None and \\\r\n clone._distinct is None and clone._simple_distinct is not True and \\\r\n <we're not doing any important joins>:\r\n```\r\n\r\nSince the problem seems to be the removal of the columns which are used for joining subqueries later.", "Maybe the issue is the group by not lining up actually...", "I think the patch from cb6cc1d should address the issue, thanks for reporting." ]

[]

[]

[ "I'm unclear on why this patch is necessary. Granted, Peewee could do a lot more introspection to detect whether the connection is closed or not, but this method is intended more to refer to the \"peewee\" connection state rather than the \"driver\" connection state.", "I'm going to pass on this -- connections dying unexpectedly probably *should* raise an `InterfaceError`.", "I have described my situation at https://github.com/coleifer/peewee/pull/1779#issuecomment-436895926.\r\nDuring some exceptions, `self._state.conn.closed` became non zero, but `self._state.closed` is still `False`.", "> I'm going to pass on this -- connections dying unexpectedly probably _should_ raise an `InterfaceError`.\r\n\r\nBy the way, when connection is dying, peewee doesn't switch `self._state.closed` to `True`.\r\nSo every next request will fail here\r\n```python\r\ndef cursor(self, commit=None):\r\n if self.is_closed():\r\n self.connect()\r\n return self._state.conn.cursor()\r\n```\r\nbecause `self.is_closed()` returns `False`, but connection is dead (`self._state.conn.closed != 0`)", "Correct - it is necessary to implement reconnect logic.", "do you think, there is no bug in peewee in this case?" ]

[]

[]

[ "I'm unclear on when this would occur? Take a look at the code to `execute_sql()`:\r\n\r\n```python\r\n def execute_sql(self, sql, params=None, commit=SENTINEL):\r\n logger.debug((sql, params))\r\n if commit is SENTINEL:\r\n if self.in_transaction():\r\n commit = False\r\n elif self.commit_select:\r\n commit = True\r\n else:\r\n commit = not sql[:6].lower().startswith('select')\r\n\r\n with __exception_wrapper__:\r\n cursor = self.cursor(commit)\r\n try:\r\n cursor.execute(sql, params or ())\r\n except Exception:\r\n if self.autorollback and not self.in_transaction():\r\n self.rollback()\r\n raise\r\n else:\r\n if commit and not self.in_transaction():\r\n self.commit()\r\n return cursor\r\n```\r\n\r\nYou can see that we call `cursor = self.cursor(...)`, so what happens in the `cursor` method?\r\n\r\n```python\r\n def cursor(self, commit=None):\r\n if self.is_closed():\r\n self.connect()\r\n return self._state.conn.cursor()\r\n```\r\n\r\nPeewee is already checking if the conn is closed, and if so, it will connect and obtain a DB-API cursor from the driver.\r\n\r\nSo what is going on in your example? Is the connection being closed by the server midway through the query execution or something?\r\n\r\nIn that case, the underlying connection wouldn't appear closed *anyways* since Peewee's determination about whether the conn is closed or not refers only to the internal state within Peewee -- not the actual *liveness* of the connection.\r\n\r\nIt seems like trading one exception for another, and I'm OK with the current behavior.", "Let's see, what happens in `execute_sql` using `PostgresqlDatabase` with `psycopg2 == 2.7.3`\r\nSection\r\n```python\r\n try:\r\n cursor.execute(sql, params or ())\r\n except Exception:\r\n if self.autorollback and not self.in_transaction():\r\n self.rollback()\r\n raise\r\n else:\r\n if commit and not self.in_transaction():\r\n self.commit()\r\n```\r\nDuring `cursor.execute` there may be an exception like\r\n```\r\nOperationalError: server closed the connection unexpectedly\r\n\tThis probably means the server terminated abnormally\r\n\tbefore or while processing the request.\r\n```\r\nor\r\n```\r\nOperationalError: could not connect to server: Connection timed out\r\n\tIs the server running on host \"XXX\" (1.1.1.1) and accepting\r\n\tTCP/IP connections on port 6432?\r\ncould not make a writable connection to server \"YYY:6432\"\r\ncould not make a writable connection to server \"ZZZ:6432\"\r\n```\r\nThan, psycopg2 connection object became something like this\r\n```\r\n>> self._state.conn.closed\r\n2\r\n```\r\nAfterwards, when we catch this `OperationalError` and call `self.rollback()` psycopg2 driver raises exception `InterfaceError: connection already closed`.\r\nIn this case we will see in logs only `InterfaceError`, original `OperationalError` will be lost. I spent too many debug hours to find this problem.", "You might consider not using autorollback?", "Sure, i can reproduce this code in each database request, but autorollback functionality is still broken." ]

[]

[]

[ "The update from 2.x to 3.x has a lot more changes than just that:\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/changes.html" ]

[]

[]

[ "The recursion error is because you are creating a stack whose length exceeds the stack depth set by the interpreter. Of course you can always manually extend this: https://docs.python.org/3/library/sys.html#sys.setrecursionlimit\r\n\r\nThe problem here:\r\n\r\n```pycon\r\n>>> expression = False\r\n>>> from terminallib import Terminal\r\n>>> for tid, cid in terminals:\r\n... expression |= (Terminal.tid == tid) & (Terminal.customer == cid)\r\n```\r\n\r\nSo you're building up an OR-ed expression that has ~1000 terms (and each of those terms is composed of two expressions). Some SQL databases won't let you do that, so even if you increase your python limits, you'll run into limits from your database.\r\n\r\nMy opinion, in other words, is that you're doing it wrong." ]

[]

[]

[ "I merged a similar patch that is roughly equivalent: 2018e579ac81db5113a26e55ce9078cc80bab446\r\n\r\nI have also removed all references to QualifiedNames in the tests -- the helper is no longer needed as the query-builder handles it correctly now. ", "Awesome, thanks! " ]

[]

[]

[ "The build is passing, which builds against python 2.x/3.x across postgres/mysql/sqlite, so that's fantastic.\r\n\r\nI'm happy to merge this patch and will probably add some regression tests in `tests/regressions.py`. I'm not sure if there are any weird, unintended effects that will crop up from wrapping the WHERE clause in a `scope_normal()` but I hope to clarify that with some additional regression/integration tests.", "Found one regression, where the right-hand-side of the assignment is a subquery. e.g. to append a user's tweet count to their username:\r\n\r\n```python\r\nsubq = Tweet.select(fn.COUNT(Tweet.id)).where(Tweet.user == User.id)\r\nquery = User.update(username=User.username + '-' + subq)\r\n```", "I have reverted this patch, as it contains a pretty serious regression (which unfortunately was not covered by a test). You can see the test-cases that illustrate the issue:\r\n\r\nbc4f04886253d81219a5b2e3a7af48bdce22160a\r\n\r\nIf you can find a workaround I'd be happy to merge.\r\n\r\nAlternatively, you can always wrap your own values in `QualifiedNames` before using them on the right-hand-side of the UPDATE?", "I've merged a patch that implements half of what this patch changed: the \"normal scope\" for the WHERE clause. I've also extended that to apply to the WHERE clause of DELETE queries. However, the QualifiedNames change is still absent due to problems described in my previous comment.", "Nice catch! I'll give it a go tomorrow using the new regression tests.\r\n\r\nAlso, I am not sure, but I think the RETURNING clause would need `QualifiedNames` too.\r\n\r\nThank you!", "I'm pretty sure you cannot use qualified names in the returning clause, but feel free to try it out. " ]

[]

[]

[ "Merged a fix that allows:\r\n\r\n* 32-character hexadecimal string representation\r\n* 16-byte raw binary representation\r\n\r\nThis should solve your problem!" ]

[]

[]

[ "Apologies -- the docs are incorrect. Peewee used \"longtext\" up until 3.x, at which point it changed to just plain old \"text\".\r\n\r\nTo have a longtext field:\r\n\r\n```python\r\nclass LongTextField(TextField):\r\n field_type = 'LONGTEXT'\r\n```\r\n\r\nThen just use it as you would a regular `TextField`." ]

[]

[]

[ "No. `get_or_create` is a hack and I don't advise anyone to use it under any circumstances. It's vulnerable to race-conditions and weird behavior. Just write the extra 2-3 lines of code and do it right. Wrap it up in a classmethod on the model it pertains to. You can thank me later." ]

[]

[]

[ "I wouldn't call that trickery, I'd call it ... well, nevermind.\r\n\r\nJust use an actual junction table. Play to the strengths of your relational database.", "Sorry to resurrect an old thread, but if anyone (like me) is looking for a similar thing: have a look at the [ManyToManyField](http://docs.peewee-orm.com/en/latest/peewee/api.html#ManyToManyField)" ]

[]

[]

[ "* http://docs.peewee-orm.com/en/latest/peewee/api.html?highlight=choices#Field\r\n* http://docs.peewee-orm.com/en/latest/peewee/models.html?highlight=choices#some-fields-take-special-parameters\r\n\r\n> Both default and choices could be implemented at the database level as DEFAULT and CHECK CONSTRAINT respectively, but any application change would require a schema change. Because of this, default is implemented purely in python and **choices are not validated but exist for metadata purposes only.**", "If you want to enforce a particular value that should be done using a CHECK constraint:\r\n\r\n```python\r\nstatus = CharField(constraints=[Check(\"status IN ('S', 'F', 'U')\")])\r\n```" ]

[]

[]

[ "So peewee sees that you're aliasing a column value to an attribute that is a field on the given model (e.g., you're aliasing a string to the name \"genus\"), which happens to be a foreign-key. Peewee assumes that the value you're storing in the foreign-key field attribute is of the same type as the field would usually store -- an integer ID.\r\n\r\nTo work around this, just use a different alias that doesn't conflict with a field name.\r\n\r\n```python\r\n qs = (Host\r\n .select(Host.id, TaxName.name.alias('genus_name'))\r\n .join(TaxName, on=((Host.genus == TaxName.tax) &\r\n (TaxName.name_class == 'scientific name'))))\r\n\r\n # or\r\n subq = (TaxName\r\n .select(TaxName.tax.alias('id'), TaxName.name)\r\n .where(TaxName.name_class == 'scientific name')).alias('subq')\r\n qs = (Host\r\n .select(Host.id, subq.c.name.alias('genus_name'))\r\n .join(subq, on=(Host.genus == subq.c.id)))\r\n```\r\n\r\nThat's less confusing, anyways, I would think, since your foreign-key attribute is not being overwritten with a string value.", "@coleifer Yep, I tried to rename alias and it works fine. But I'd like to use the same name. So I used the first variant (without subquery). Thanks!" ]

[]

[]

[]

[]

[]

[ "wrong submit." ]

[]

[]

[]

[]

[]

[ "It's returning a list of tag instances...you need to:\r\n\r\n```python\r\ndef get_tagsID(self):\r\n tagQ = tag_list.select(tag_list.id)\r\n return [tl.id for tl in tagQ]\r\n```\r\n\r\nAlso python typically prefers lower case w/underscores instead of that camelCase just fyi.", "By the way, try reading the error message...it seems completely obvious to me at least.", "Thank you, it works perfectly. No sorry, don't understand the error... " ]

[]

[]

[ "Have you tried with a file-based database? That might provide a clue.\r\n\r\nNo idea but it's certainly not a peewee issue." ]

[]

[]

[ "I don't understand the code.\r\n\r\nFor sqlite json, I imagine it is possible but not sure off the top of my head." ]

[]

[]

[ "FWIW, what I really want in this case is probably something closer to Postgres's `array_agg`, but postgres also has `json_agg`, `json_object_agg`, etc that have their own use case with regards to returning dicts. Also, I'm pretty tied to using sqlite.", "I've made a patch which somewhat addresses this issue... The following explanation applies to Peewee <= 3.7.1 (up through commit aa2d6f51dc2f50e4):\r\n\r\nBecause these are aggregate functions, they do not easily lend themselves to introspection or a sensible API. We wouldn't make \"group_array\" a method on a `JSONField`, for instance, because it's an aggregate and operates outside the scope of a single column. In your snippet there's nothing to indicate that the returned value is a json-serialized string other than the function name.\r\n\r\nSimilarly, when reading the result value from the db cursor, we don't have an obvious indication that the results are a json-serialized string other than the function name itself. To see how peewee translates the raw data from a cursor into the appropriate data-types, check out `BaseModelCursorWrapper._initialize_columns()`. In fact, depending on the data-type being grouped, its possible that Peewee could attempt (incorrectly) to convert the serialized values. If you change your example to group the Tweet's \"id\" field you will get an error.\r\n\r\n```python\r\nname, messages = (User.select(User.name,\r\n fn.json_group_array(Tweet.id))\r\n .join(Tweet)\r\n .where(User.id == 123)\r\n .scalar(as_tuple=True))\r\n```\r\n\r\nThis will raise an error in peewee <= 3.7.1 -- \"invalid literal for int...\" -- because Peewee uses a heuristic to try and normalize the values returned by aggregates -- which is, it looks at the first parameter in the function call and, if its a Field object, will assume that the result of the aggregate returns a compatible data-type. To avoid this, you need to:\r\n\r\n```python\r\nname, messages = (User.select(User.name,\r\n fn.json_group_array(Tweet.id).coerce(False))\r\n .join(Tweet)\r\n .where(User.id == 123)\r\n .scalar(as_tuple=True))\r\n```\r\n\r\n---------------------\r\n\r\nBack to your question -- because the column you are aggregating into a json value is not necessarily a JSONField (and in fact is probably not) -- there's nothing to indicate to peewee that the value returned by the db is a json string.\r\n\r\nI've made some changes to the internals, however:\r\n\r\n1. When inferring a conversion for a SQL function, ignore TypeError / ValueError that is raised when applying conversion. (e.g., calling int(), which is Tweet.id's conversion function, on the result of a group_concat).\r\n2. Make it possible for a function to explicitly declare a conversion. This makes it possible to specify a custom conversion function on a one-off basis.\r\n\r\nExample of 2, which should address your problem:\r\n\r\n```python\r\nname, messages = (User.select(User.name,\r\n fn.json_group_array(Tweet.message).python_value(json.loads))\r\n .join(Tweet)\r\n .where(User.id == 123)\r\n .scalar(as_tuple=True))\r\n```", "ecfa98c9f2d5d6b30f238d97928662d909f769e2", "I was thinking of full extension support like `remove()`, `length()` etc but that works!\r\nhttp://docs.peewee-orm.com/en/latest/peewee/sqlite_ext.html#JSONPath.remove\r\n\r\nFYI, looks like there's an issue with the `remove()` docstring; it claims to use the `json_type` function.", "Right, but it makes no sense calling json_group_xxx from the context of a json field or path (?)." ]

[]

[]

[ "You should use `manytomany=True`:\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/playhouse.html#model_to_dict" ]

[]

[]

[ "Nope, not at present anyways." ]

[]

[]

[ "You have a couple options.\r\n\r\nYou can specify `on_delete='cascade'`, which will automatically delete the DataTag objects when a Data or Tag gets deleted:\r\n\r\n```python\r\ntags = ManyToManyField(Tag, backref='data', on_delete='cascade')\r\n```\r\n\r\nOr, you can specify ``recursive=True`` when calling `delete_instance()`.\r\n\r\n```python\r\ndb_data.delete_instance(recursive=True)\r\n```" ]