Datasets:

---

akumoth

/

peewee-issues

like 0

[]

[]

[]

[]

[]

[ "Presumably you would do any data-processing before throwing it into Peewee...Peewee is your layer for talking to the database, in a clean design it should probably not also be your business-logic layer. You're probably best off just overriding the `save()` method rather than messing with the signals API, though of course that's an option.", "Thanks!" ]

[]

[]

[ "That is a kind of weird construction...typically wouldn't you write instead:\r\n\r\n```python\r\nsubquery = Team.select().where(Team.id == 1)\r\nquery = User.select().where(User.team.in_(subquery))\r\n```", "In this minimal example, perhaps. The actual use of this construction will of course be more complex (both the primary and subquery) and I need the boolean result of the `in` statement alongside other data.", "Fixed, thanks for reporting.", "Awesome! Thanks for the fast fix." ]

[]

[]

[ "Refer to [this table](http://docs.peewee-orm.com/en/latest/peewee/models.html#field-types-table) for fields that are currently supported in peewee.\r\n\r\nFor any other database specific types, you can easily create a [custom field](http://docs.peewee-orm.com/en/latest/peewee/models.html#creating-a-custom-field).\r\n\r\nExample:\r\n```\r\nclass TinyIntegerField(IntegerField):\r\n field_type = 'TINYINT'\r\n```", "ok thanks!", "Btw do you think it really matters perforamnce wise if i switch to tinyint?\r\nThis is a field with a value from 1 to 5.", "You won't get any performance gain from peewee itself.\r\n\r\nBut depending on your database implementation/set up in regards to indexing, storage and so forth, you might see some gain.", "Thanks!" ]

[]

[]

[ "You can easily override the default naming.\r\n\r\n```\r\nclass Project(Model):\r\n class Meta:\r\n table_name = 'projects'\r\n```\r\n\r\nSee [here](http://docs.peewee-orm.com/en/latest/peewee/models.html#model-options-and-table-metadata) for more.", "I knew about this I was thinking of making the table name function automatically append the 's' at the end of the table name. But I guess this is good enough too...", "You can of course do a custom class that will create the model to be used with a generated table name .\r\n\r\nhttps://github.com/coleifer/peewee/blob/ccf8ac09e6cd571a3becea0b31af9418fcb05a94/playhouse/kv.py#L55\r\n\r\nLook at the above class for an example how to accomplish that.\r\n\r\nBit of a tricky case determining plurals, simply adding \"s\" doesn't make every word automatically plural, but if you use simple words, I guess you'll be fine.", "There is an example of a custom table naming function here: http://docs.peewee-orm.com/en/latest/peewee/models.html#table-names\r\n\r\nCode from docs:\r\n\r\n```python\r\ndef make_table_name(model_class):\r\n model_name = model_class.__name__\r\n return model_name.lower() + '_tbl'\r\n\r\nclass BaseModel(Model):\r\n class Meta:\r\n table_function = make_table_name\r\n\r\nclass User(BaseModel):\r\n # table_name will be \"user_tbl\".\r\n\r\nclass UserProfile(BaseModel):\r\n # table_name will be \"userprofile_tbl\".\r\n```" ]

[]

[]

[ "Would this query be equivalent?\r\n\r\n```python\r\nresults = (table1.select(...)\r\n .from_(table1, table2)\r\n .join_from(table1, table3, JOIN.LEFT_OUTER, ((table3.table1_id == table1.id) & ...))\r\n .where(table3.is.is_null()))\r\n```", "That produces a different query, and also errors with `invalid reference to FROM-clause entry for table \"t1\" Hint: There is an entry for table \"t1\", but it cannot be referenced from this part of the query.`\r\n\r\nI've managed to get around it with a raw query.", "Well, I get that the SQL is different, but semantically aren't they equivalent? i.e. multiple tables in a FROM clause is the same as a cross join, right?", "I'm unsure in this case because postgres returns the error I mentioned, whereas the query in my initial message returns successfully, with results.", "I think you must have a typo or something, because it works fine for me:\r\n\r\n```python\r\nfrom peewee import *\r\n\r\n\r\ndb = SqliteDatabase(':memory:')\r\n\r\nclass Base(Model):\r\n class Meta:\r\n database = db\r\n\r\nclass A(Base):\r\n id = AutoField()\r\n\r\nclass B(Base):\r\n id = AutoField()\r\n\r\nclass C(Base):\r\n id = AutoField()\r\n a = ForeignKeyField(A)\r\n b = ForeignKeyField(B)\r\n\r\ndb.create_tables([A, B, C])\r\n\r\nA.insert_many([(1,), (2,), (3,)], fields=[A.id]).execute()\r\nB.insert_many([(1,), (2,)], fields=[B.id]).execute()\r\nC.insert_many([\r\n (1, 1, 1),\r\n (2, 1, 2),\r\n (3, 2, 1)], fields=[C.id, C.a, C.b]).execute()\r\n\r\nquery = (A\r\n .select(A.id.alias('aid'), B.id.alias('bid'), C.id.alias('cid'))\r\n .from_(A, B)\r\n .join_from(A, C, JOIN.LEFT_OUTER, on=(\r\n (C.a == A.id) &\r\n (C.b == B.id)))\r\n .where(C.id.is_null()))\r\n\r\nfor row in query.tuples():\r\n print(row)\r\n\r\nprint('\\n-----\\n')\r\n\r\nquery = ('select a.id, b.id, c.id '\r\n 'from a '\r\n 'cross join b '\r\n 'left join c on c.a_id = a.id and c.b_id = b.id '\r\n 'where c.id is null')\r\nfor row in db.execute_sql(query):\r\n print(row)\r\n```\r\n\r\nIn both cases it prints:\r\n\r\n```\r\n(2, 2, None)\r\n(3, 1, None)\r\n(3, 2, None)\r\n\r\n-----\r\n\r\n(2, 2, None)\r\n(3, 1, None)\r\n(3, 2, None)\r\n```", "> in this case because postgres returns the error I mentioned\r\n\r\nYou're right -- it worked fine in SQLite but Postgresql does not allow mixing multiple \"from\"-clause items with a JOIN.", "Working up a fix.", "Thanks for your patience, I tested on SQLite and assumed it was good-to-go. It's fixed for real now, your original query should be working with the latest commit.", "No worries. You're an absolute star for getting on this so quickly!" ]

[]

[]

[ "I don't think you're quite right that Peewee is using single-quotes around 'id' and 'name'. Peewee would presumably be using double-quotes.\r\n\r\nEx:\r\n\r\n```python\r\nIn [1]: from peewee import *\r\n\r\nIn [2]: db = PostgresqlDatabase('peewee_test', user='postgres')\r\n\r\nIn [3]: class GS(Model):\r\n ...: name = TextField()\r\n ...: class Meta:\r\n ...: database = db\r\n ...: \r\n\r\nIn [4]: GS.insert(id=12345, name='yoshi').on_conflict(conflict_target=[GS.id], preserve=[GS.name]).sql()\r\nOut[4]: \r\n('INSERT INTO \"gs\" (\"id\", \"name\") VALUES (%s, %s) ON CONFLICT (\"id\") DO UPDATE SET \"name\" = EXCLUDED.\"name\" RETURNING \"id\"',\r\n [12345, 'yoshi'])\r\n```\r\n\r\nSo I'm not sure if you have just mistyped your issue or what?", "Could you paste the exact error you are receiving from CockroachDB? \r\n\r\nDo normal INSERTs work (without the ON CONFLICT clause)?", "I just set up a Cockroach cluster on my computer and it seems to work fine:\r\n\r\n```python\r\nIn [1]: from peewee import *\r\n\r\nIn [2]: db = PostgresqlDatabase('peewee_test', user='root', port=26257)\r\n\r\nIn [3]: db.connect()\r\nOut[3]: True\r\n\r\nIn [4]: class KV(Model):\r\n ...: key = TextField(unique=True)\r\n ...: value = TextField()\r\n ...: class Meta:\r\n ...: database = db\r\n ...: \r\n\r\nIn [5]: KV.create_table()\r\n\r\nIn [6]: k1=KV.create(key='k1', value='v1')\r\n\r\nIn [7]: k1\r\nOut[7]: <KV: 381083568020553729>\r\n\r\nIn [8]: KV.insert(key='k1', value='v1-x').on_conflict(conflict_target=[KV.key], preserve=[KV.value])\r\nOut[8]: <peewee.ModelInsert at 0x7f0bb8bfc080>\r\n\r\nIn [9]: KV.insert(key='k1', value='v1-x').on_conflict(conflict_target=[KV.key], preserve=[KV.value]).execute()\r\nOut[9]: 381083568020553729\r\n\r\nIn [10]: list(KV)\r\nOut[10]: [<KV: 381083568020553729>]\r\n\r\nIn [11]: KV.get(KV.key == 'k1').value\r\nOut[11]: 'v1-x'\r\n```", "my query is\r\n```\r\nGSModel.insert_many(data, fields=['id', 'name']\r\n ).on_conflict(\r\n conflict_target=[GSModel.id], \r\n preserve=[GSModel.name],\r\n update={}).execute()\r\n```\r\nand in pycharm i see this:\r\n\r\n```\r\n.../lib/python3.7/site-packages/peewee.py\", line 2640, in execute_sql\r\n cursor.execute(sql, params or ())\r\npeewee.ProgrammingError: syntax error at or near \"id\"\r\nDETAIL: source SQL:\r\nINSERT INTO \"gs\" ('id', 'name') VALUES (379589221701287937, 'afghans'), (379589221701320705, 'agar-agar') ON CONFLICT (\"id\") DO UPDATE SET \"name\" = EXCLUDED.\"name\" RETURNING \"id\"\r\n```", "if I print sql():\r\n```\r\n('INSERT INTO \"gs\" (%s, %s) VALUES (%s, %s), (%s, %s) ON CONFLICT (\"id\") DO UPDATE SET \"name\" = EXCLUDED.\"name\" RETURNING \"id\"', ['id', 'name', 379589221701353473, 'albatre', 379589221701386241, 'albumine'])\r\n```", "Your columns are being treated as if they were strings. You need to use the field instances themselves:\r\n\r\n```python\r\nGSModel.insert_many(data, fields=[GSModel.id, GSModel.name])...\r\n```", "I've fixed the logic in bulk INSERT so that it is now possible to provide the list of fields as a list of strings -- this makes things a bit more flexible and should prevent anyone from shooting themselves in the foot in the future. For what it's worth, the docs are pretty clear that you should be specifying field instances as opposed to strings:\r\n\r\n* http://docs.peewee-orm.com/en/latest/peewee/querying.html#bulk-inserts\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#Model.insert_many", "originally I was using the instances but switched to strings because of this:\r\n```\r\nlib/python3.7/site-packages/peewee.py\", line 2226, in _generate_insert\r\n raise ValueError('Missing value for \"%s\".' % column)\r\nValueError: Missing value for \"<IntegerField: GSModel.id>\".\r\n```\r\n", "ok I found out my mistake...\r\nmixing dicts with `fields=` was the root cause of my problem today... I needed to use tuples. \r\nit gave me the Missing value err ^.... then I switched to strings to get rid of the error , only to get the insert error later I posted as issue.\r\n\r\n```\r\n# don't do this:\r\ndata_source = [\r\n {'field1': 'val1-1', 'field2': 'val1-2'},\r\n {'field1': 'val2-1', 'field2': 'val2-2'},\r\n # ...\r\n]\r\nMyModel.insert_many(data_source, fields=[MyModel.field1, MyModel.field2]).execute()\r\n```", "Yeah, if you specify *both* a list of dicts and the *fields* parameter, then the fields need to match the keys of the dictionary -- which in your case caused trouble because the keys were strings and the fields were objects." ]

[]

[]

[ "`backref` is the correct way -- `related_name` was used prior to Peewee 3.0 and is deprecated, but they have the same effect.\r\n\r\nYou are running into a circular import problem. Consider re-architecting your modules or become more familiar with how python imports work.\r\n\r\nPeewee follows the convention of using `id = AutoField()` (which is an auto-incrementing integer primary key). If no primary key is specified explicitly by the user, then the model will automatically have this `id` field.\r\n\r\n```python\r\nclass Todo(Model):\r\n task_name = TextField()\r\n\r\nclass TodoItem(Model):\r\n todo = ForeignKeyField(Todo, backref='items')\r\n item_name = TextField()\r\n```\r\n\r\nYou can also explicitly specify the column the foreign-key references by specifying \"field=...\". The following is equivalent to the above.\r\n\r\n```python\r\nclass TodoItem(Model):\r\n todo = ForeignKeyField(Todo, field='id', backref='items')\r\n ...\r\n```", "Thanks @coleifer! I would reread the version of the documentation I am using. I think I did not see most of what you just have said about ForeignKeyField parameters and column/field name convention in the documentation. Anyways, thanks for the clarification." ]

[]

[]

[]

[]

[]

[ "```.where(fn.LENGTH(SomeModel.name) < 45)```", "http://docs.peewee-orm.com/en/latest/peewee/querying.html#filtering-records", "thank you" ]

[]

[]

[ "Thanks for reporting, this is now fixed.", "thx! so fast) when next release?", "There are quite a few changes, I'll probably tag 3.7.0 here in the next week or so." ]

[]

[]

[ "Rather than querying from the perspective of Account (which may have 0..n codes), you should query from the intermediary model and eagerly load the associated account/code:\r\n\r\n```python\r\nquery = (AccountCode\r\n .select(AccountCode, Account, Code)\r\n .join_from(AccountCode, Account)\r\n .join_from(AccountCode, Code)\r\n .where(AccountCode.account = account_id))\r\nfor acc_code in query:\r\n # acc_code.account or acc_code.code are already loaded so no more queries\r\n```\r\n\r\nFor your example to work, peewee would have to de-duplicate data to ensure all the codes were assigned to a single account." ]

[]

[]

[ "This is already possible, if I understand the request correctly.\r\n\r\nWhen adding a new column, you can add arbitrary constraints:\r\n\r\n```python\r\nprice = FloatField(default=0., constraints=[Check('price >= 0.0')])\r\nmigrator = SchemaMigrator.from_database(db)\r\n# Add the \"price\" column, which includes a CHECK() constraint.\r\nmigrate(migrator.add_column('some_table', 'price', price))\r\n```", "Perhaps you were referring to table constraints? e.g. `ALTER TABLE ADD CONSTRAINT ...`?", "Added support for adding/dropping generic table constraints: https://github.com/coleifer/peewee/commit/128e41ce16473baaeb24cc74864a088884a7e0cb#diff-77fadcec703631c9bc463a8865569f1bR2999" ]

[]

[]

[ "Peewee needs you to specify the join predicate when using models that don't have a foreign-key relationship, simple as that.\r\n\r\nIs there any reason why you wouldn't just:\r\n\r\n```python\r\nclass ModelB(BaseModel):\r\n class Meta:\r\n table_name = 'model_b'\r\n\r\n model_b_id = IntegerField() # presumably this should have primary_key=True?\r\n model_a = ForeignKeyField(ModelA)\r\n```\r\n\r\nNote that if you're using the lower-level query builder APIs these constraints do not exist and you can express a natural join:\r\n\r\n```python\r\nTableA = ModelA._meta.table\r\nTableB = ModelB._meta.table\r\nTableC = ModelC._meta.table\r\n\r\nquery = (TableA\r\n .select(TableA.model_a_id, TableB.model_b_id, TableC.model_c_id)\r\n .join(TableB, JOIN.NATURAL)\r\n .join(TableC, JOIN.NATURAL))\r\n```", "The example given is a dumbed-down version of my actual database to demonstrate the issue. In reality there are 2-3 fields required to perform the joins using compound primary keys. These compound keys serve as the mechanism for natural joins in the existing database structure, a better example would have been:\r\n\r\n```python\r\nfrom peewee import (JOIN, CompositeKey, DateField, DateTimeField, IntegerField,\r\n Model, PostgresqlDatabase, TextField)\r\n\r\ndb = PostgresqlDatabase('test_db')\r\n\r\nclass BaseModel(Model):\r\n class Meta:\r\n database = db\r\n\r\nclass ModelA(BaseModel):\r\n class Meta:\r\n table_name = 'model_a'\r\n primary_key = CompositeKey('first_identifier', 'second_identifier')\r\n\r\n first_identifier = IntegerField()\r\n second_identifier = IntegerField()\r\n third_reference = TextField()\r\n model_a_data = TextField()\r\n\r\nclass ModelB(BaseModel):\r\n class Meta:\r\n table_name = 'model_b'\r\n primary_key = CompositeKey('second_identifier', 'timestamp')\r\n\r\n second_identifier = IntegerField()\r\n timestamp = DateTimeField()\r\n third_reference = TextField()\r\n model_b_data = TextField()\r\n\r\nclass ModelC(BaseModel):\r\n class Meta:\r\n table_name = 'model_c'\r\n primary_key = CompositeKey('third_reference', 'date')\r\n\r\n third_reference = TextField()\r\n date = DateField()\r\n model_c_data = TextField()\r\n\r\nwith db:\r\n db.create_tables([ModelA, ModelB, ModelC])\r\n\r\n# vvv works vvv\r\nprint((ModelA._meta.table\r\n .select(\r\n ModelA.model_a_data,\r\n ModelB.model_b_data,\r\n ModelC.model_c_data\r\n )\r\n .join(ModelB._meta.table, JOIN.NATURAL)\r\n .join(ModelC._meta.table, JOIN.NATURAL)\r\n).execute()[0])\r\n\r\n# vvv errors vvv\r\nprint((ModelA\r\n .select(\r\n ModelA.model_a_data,\r\n ModelB.model_b_data,\r\n ModelC.model_c_data\r\n )\r\n .join_from(ModelA, ModelB, JOIN.NATURAL)\r\n .join_from(ModelA, ModelC, JOIN.NATURAL)\r\n).execute()[0])\r\n```\r\n\r\nGood to know I can revert to using the tables, just raised the issue because natural joins don't actually require a foreign key relationship.", "I think I'm going to close this one out as partially wontfix. Peewee nominally supports natural joins, but they were added in 3.x, and to-date, Peewee still does not support the \"USING ...\" clause that typically goes with a natural join.\r\n\r\nWhen using models, Peewee requires a join predicate -- either supplied by the user or inferred from the declared foreign-key relationships. Cartesian joins can be accomplished by specifying multiple tables in the from clause (using `.from_(Src1, Src2, ...)`)." ]

[]

[]

[ "```python\r\nfrom peewee import NodeList\r\n\r\nfn.GROUP_CONCAT(NodeList((\r\n MyModel.test_score.distinct(), \r\n SQL('ORDER BY'), \r\n MyModel.test_score.desc(), \r\n SQL('SEPARATOR \\' \\''))\r\n))\r\n```\r\n\r\nINTO:\r\n\r\n```sql\r\nGROUP_CONCAT(DISTINCT \"t1\".\"test_score\" ORDER BY \"t1\".\"test_score\" DESC SEPARATOR ' ')\r\n```", "Cool, thanks. :)" ]

[]

[]

[ "e15141fb519e175970af73dac92b736011208541" ]

[]

[]

[ "You mean quotation marks, not parentheses...", "I think the better way to fix this would be to introspect the field type rather than the default value.", "You are right ... \"quotation marks\" it is. \r\n\r\nI decided to check the type of the default value because even if you have a certain numeric field type the default value could be any type depending on the users input. E.g. the following is certainly possible:\r\n\r\n import peewee as pw\r\n class A(pw.Model):\r\n name = pw.CharField(default=1)\r\n num = pw.IntegerField(default=\"foo\")\r\n\r\nI know it makes no sense but peewee allows to set defaults that don' t match the field type. Maybe that should get checked, too. But to prevent the SQL-statement from breaking it seams better to me to check the type of the default value.\r\n" ]

[]

[]

[]

[]

[]

[ "There's no way to fix this, unfortunately it's just a limit of SQLite that it won't accept the parameterized query in CREATE INDEX.", "Indeed, I did not realize that was the case with every parametized index creation. Even the advanced index creation [stated in the doc](http://docs.peewee-orm.com/en/latest/peewee/models.html#advanced-index-creation) will fail with SQLite.\r\n\r\nWould it not be possible somehow to alter the ouput of `_create_index` to render a full SQL query rather than a parametized one in the case of SQLite ? If there is no solution to improve this, I think the documentation should mention this somehow :)" ]

[]

[]

[ "I'm not clear why you are writing your queries like that...but here's how you might do it with Peewee:\r\n\r\n```python\r\nLA1 = Log.alias()\r\nsubq1 = LA1.select(LA1).where(LA1.checked == 0).order_by(LA1.id.desc())\r\n\r\nlhs = (Log\r\n .select(subq1.c.api_id, subq1.c.id, subq1.c.new_name.alias('name'))\r\n .from_(subq1)\r\n .group_by(subq1.c.api_id))\r\n\r\nLA2 = Log.alias()\r\nsubq2 = LA2.select(LA2).where(LA2.checked == 0).order_by(LA2.id)\r\n\r\nrhs = (Log\r\n .select(subq2.c.api_id, subq2.c.id, subq2.c.new_name.alias('name'))\r\n .from_(subq2)\r\n .group_by(subq2.c.api_id))\r\n\r\nquery = lhs.union_all(rhs).order_by(SQL('1, 2'))\r\n```\r\n\r\nThe SQL that's generated is:\r\n\r\n```sql\r\nSELECT \"t1\".\"api_id\", \"t1\".\"id\", \"t1\".\"new_name\" AS \"name\" \r\nFROM (\r\n SELECT \"t2\".\"id\", \"t2\".\"api_id\", \"t2\".\"timestamp\", \"t2\".\"new_name\", \"t2\".\"old_name\", \"t2\".\"checked\" \r\n FROM \"log\" AS \"t2\" \r\n WHERE (\"t2\".\"checked\" = ?) \r\n ORDER BY \"t2\".\"id\" DESC) AS \"t1\" \r\nGROUP BY \"t1\".\"api_id\" \r\nUNION ALL \r\nSELECT \"t3\".\"api_id\", \"t3\".\"id\", \"t3\".\"new_name\" AS \"name\"\r\nFROM (\r\n SELECT \"t4\".\"id\", \"t4\".\"api_id\", \"t4\".\"timestamp\", \"t4\".\"new_name\", \"t4\".\"old_name\", \"t4\".\"checked\" \r\n FROM \"log\" AS \"t4\" \r\n WHERE (\"t4\".\"checked\" = ?) \r\n ORDER BY \"t4\".\"id\"\r\n) AS \"t3\" \r\nGROUP BY \"t3\".\"api_id\" \r\nORDER BY 1, 2\r\n```", "@coleifer I just want to select latest and soonest row of each group which is grouped by api_id，and are there effective way to implement it with peewee，appreciate your help", "Check out this post, which talks about various ways to approach the \"top item per group\" query: http://charlesleifer.com/blog/techniques-for-querying-lists-of-objects-and-determining-the-top-related-item/\r\n\r\nIt's a common thing and there are several ways to do it.\r\n\r\nYou might find it easier to do something like:\r\n\r\n```python\r\nLA = Log.alias()\r\nsubq = (LA.select(\r\n LA.api,\r\n fn.MIN(LA.id).alias('min_id'), \r\n fn.MAX(LA.id).alias('max_id'))\r\n.group_by(LA.api)\r\n.where(LA.checked == 0))\r\n\r\nquery = Log.select().join(subq, on=(\r\n (Log.api == subq.c.api_id) &\r\n ((Log.id == subq.c.min_id) | (Log.id == subq.c.max_id)))\r\n```" ]

[]

[]

[ "From your issue it's unclear what the problem is, what the expected result/output should be, etc.\r\n\r\nCan you please add a comment indicating what the problem is? Also, if you could please create a minimal example -- the models you've included are difficult to read.\r\n\r\nI'll reopen the issue upon receiving a comment.", "```\r\nexample model:\r\nclass t1(BaseModel):\r\n name = CharField() \r\n intro_title = CharField() \r\n primary_key = CharField(index = True)\r\nclass t2(BaseModel):\r\n name = CharField() \r\n primary_key = CharField(index = True)\r\n director = CharField()\r\n actor = CharField()\r\n```\r\n\r\nMy main requirement is to judge whether t1.name and t2.name contain the keyword according to the keyword input by the user. If it is included, the content that matches t1 and t2 is combined and output.\r\nT1 and t2 can be combined by primary_key.\r\n\r\nmy query:\r\n```\r\n queryt1 = t1.where(t1.name.contains(kw))\r\n queryt2 = t2.where(t2.name.contains(kw))\r\n query = ((queryt1\r\n.select(queryt1, queryt2)\r\n.join(queryt2, JOIN.LEFT_OUTER, on= queryt1.primary_key == queryt2.primary_key))\r\nunion_all\r\n(queryt1\r\n.select(queryt1, queryt2)\r\n.join(queryt2, JOIN.RIGHT_OUTER, on= queryt1.primary_key == queryt2.primary_key))\r\n.where(queryt1.primary_key == None))\r\n```\r\n\r\nBut my output is only t1 content, no t2 content\r\n\r\n\r\n ", "Your query is all sorts of wrong... I'd suggest posting to stackoverflow." ]

[]

[]

[ "Peewee lazily evaluates queries -- they are not evaluated until iterated (or you explicitly call .execute(), and in that case you get a special/smart iterator).\r\n\r\nTo get a list of dicts, either:\r\n\r\n```python\r\nq = User.select().dicts()\r\nlist_of_dicts1 = q[:]\r\nlist_of_dicts2 = list(q)\r\nlist_of_dicts3 = [d for d in q]\r\n```" ]

[]

[]

[ "First off, try modifying your query so that you're not selecting \"latlng\" twice:\r\n\r\n```python\r\nquery = Homes.select(Homes.name, fn.ST_AsText(Homes.latlng).alias('latlng'))\r\n```\r\n\r\nYou may not need the \".alias()\" so try with/without.", "@coleifer, thank you for the reply. Unfortunately, that does not work either. I still get the `latlng` column in binary representation:\r\n\r\n```\r\n('SELECT \"t1\".\"id\", \"t1\".\"name\", \"t1\".\"latlng\", ST_AsText(\"t1\".\"latlng\") AS \"latlng\" FROM \"homes\" AS \"t1\"', [])\r\n[{'id': 1, 'name': 'Test', 'latlng': '0101000000000000000000F03F0000000000002440'}]\r\n```", "@coleifer, I managed to make it work. As long as the `latlng` column selected first, it works:\r\n\r\n```\r\n homes = Homes.select(fn.ST_AsText(Homes.latlng).alias('latlng'), Homes).execute()\r\n print([model_to_dict(home) for home in homes])\r\n```\r\n\r\nResult:\r\n```\r\n('SELECT \"t1\".\"id\", \"t1\".\"name\", \"t1\".\"latlng\", ST_AsText(\"t1\".\"latlng\") AS \"latlng\" FROM \"homes\" AS \"t1\"', [])\r\n[{'id': 1, 'name': 'Test', 'latlng': 'POINT(1 10)'}]\r\n```", "Yes -- that was why I suggested that you explicitly declare which columns you are selecting, rather than selecting everything (which happens when you do `.select(Homes)`) and then also selecting `latlng`. Unlike SQL, which returns your rows as a table, peewee is restricted to using Python named attributes so whichever value is selected first - for a given attribute - will be used and any other values with the same attribute (\"latlng\" in this case) will be ignored." ]

[]

[]

[]

[]

[]

[ "Peewee is an active-record ORM...so when you call \".save()\" it will, by default, explicitly set the values for all columns using whatever values are stored in the model instance at that time.\r\n\r\nAdditionally, the `default=...` values only apply when the model does not already have a value for the given fields. So \"datetime.datetime.now()\" will be called the first time the model is created, but subsequently (assuming the field values are not None) the initial values will not be overwritten.\r\n\r\nYou're probably best doing something like this:\r\n\r\n```python\r\nclass Caller(Model):\r\n def save(self, *args, **kwargs):\r\n self.updated_at = datetime.datetime.now()\r\n return super(Caller, self).save(*args, **kwargs)\r\n```\r\n\r\nThat's the more commonly-used pattern with active-record ORMs like Peewee.", "Alternatively, explicitly issuing an `UPDATE` query (by calling `Caller.update()`) would probably have the effect you're looking for.\r\n\r\n```python\r\nobj = Caller.select()...first()\r\nupdate = {}\r\nif admin is not None:\r\n update[Caller.admin] = admin\r\nif key is not None:\r\n update[Caller.key] = key\r\n# etc.\r\nif update:\r\n Caller.update(update).where(Caller.id == id).execute()\r\n```", "Thank you very much!" ]

[]

[]

[ "Beautiful, thanks!" ]

[]

[]

[ "Thanks for the quick fix! I had literally just hacked around my local install with the same monkeypatch:\r\n\r\n```\r\nimport peewee\r\npeewee.__sqlite_version__ = tuple(int(x) for x in apsw.sqlitelibversion().split('.'))\r\n```" ]

[]

[]

[ "Ouch...that's going to be rather difficult to fix, unfortunately, perhaps not possible. I'd suggest in the meantime trying something like:\r\n\r\n```python\r\n.order_by(Expression(cte.c.data, '->>', SQL(\"'x'\")))\r\n```", "I'll try that, but I now realize that `select_from()` actually produces `SELECT FROM` rather than `SELECT * FROM`. If I explicitly specify columns, as in `select_from(cte.c.id, cte.c.data)` then peewee produces `SELECT \"foos\".\"id\", \"foos\".\"data\" FROM` as it should. Is it requirement for `select_from()` to always explicitly specify columns?\r\n\r\nDocs do state that:\r\n\r\n> One or more columns to select from the CTE\r\n\r\nWould making `.select_from()` to grab all (available) columns possible (so behavior would be similar to your standard `.select()`)?", "Seems like subqueries are a bit special, too:\r\n\r\n```python\r\nsubq = Foo.select()\r\nquery = Foo.select().from_(subq)\r\nquery.sql() # SELECT \"t1\".\"id\", \"t1\".\"data\" FROM (SELECT \"t1\".\"id\" FROM \"node\" AS \"t1\") AS \"t2\";\r\n```\r\n\r\nSo without columns specified:\r\n\r\n- Subquery only selects pk (`\"t1\".\"id\"`), and\r\n- Without columns explicitly specified, outer query tries to grab subquery's fields (`\"t1\".\"id\", \"t1\".\"data\"`) instead of its' own (`\"t2\"`)\r\n\r\nIf I explicitly specify columns in both subquery and outer query, then it works.\r\n\r\nAlso, `order_by()` is similarly broken with subquery (like with CTE) in that it produces non-JSON field compatible SQL. I believe subqueries and CTEs share the same code...(?)", "> Is it requirement for select_from() to always explicitly specify columns?\r\n\r\nAt present, yes, since CTEs may be declared with or without columns.\r\n\r\nSame problem and same limitations apply to referencing columns from a subselect in the outer-select, that is: peewee does not do introspection and so you need to use the \".c\" helper to reference them in both cases.", "As to the first bullet-point, subqueries will only select the primary key, unless you explicitly declare the selection. This is because the most common use-case for subqueries is \"where(id IN ...)\".", "Unfortunately, I think this is gonna have to be \"wontfix\" for the foreseeable future. When referencing columns on subqueries/ctes, peewee just doesn't have deep enough magic to resolve references to whatever field/expression they correspond to. Feel free to take a look into the code, especially the `ColumnFactory`/`_DynamicColumn` classes, which provide the implementation for the \".c\" helper.", "Ok, it's a bit more work but not a blocker.\r\n\r\nHow about making the API fail/warn/hint when user tries to do something bad, though? E.g.:\r\n\r\n> - Without columns explicitly specified [using CTE], outer query tries to grab subquery's fields (`\"t1\".\"id\", \"t1\".\"data\"`) instead of its' own (`\"t2\"`)\r\n\r\n> [CTE] `select_from()` actually produces `SELECT FROM` rather than `SELECT * FROM` [have to explicitly specify all fields]\r\n\r\nAlso, maybe add \"Subqueries\" section to http://docs.peewee-orm.com/en/latest/peewee/querying.html and mention that by default (when you don't specify anything) they only select primary key?\r\n\r\nFinally, maybe http://docs.peewee-orm.com/en/latest/peewee/querying.html?highlight=subquery#common-table-expressions could mention that peewee doesn't _have deep enough magic to resolve references to whatever field/expression they correspond to_ so you have to be explicit?", "Good suggestions, thank you." ]

[]

[]

[ "Well, `Proxy` works by overriding `__getattr__()` and `__setattr__()`...I think the crux of the issue is that these overrides do not cover special methods such as `__enter__` and `__exit__`. This is described in the [Python documentation](https://docs.python.org/3/reference/datamodel.html#special-method-lookup).\r\n\r\nThe fix in this case is to add specific overrides for `__enter__` and `__exit__` on the `Proxy` class itself. An alternative, which should work, is to use `with database_proxy.connection_context():` (which has slightly different semantics, in that it does not also automatically wrap with a transaction).", "Thank you for responding so quickly!\r\n\r\nI think that `with database_proxy.connection_context():` might work for my use case, and seems like a good solution. If not, using a custom context manager isn't bad either. Thanks!", "Well, either way it's fixed in `master` and the fix will be included in the next release." ]

[]

[]

[]

[]

[]

[ "Fixed, thanks for reporting." ]

[]

[]

[ "This is fixed in 3.5.0. See ababb51f" ]

[]

[]

[ "provide a geo point, and sorted by distance", "I'm assuming you're using something like PostGIS for Postgresql, or Spatialite for SQLite.\r\n\r\nYou just need to find the appropriate distance function and call it, e.g. [ST_distance](https://postgis.net/docs/ST_Distance.html):\r\n\r\n```python\r\nfn.ST_Distance(SomeModel.point_1, SomeModel.point_2)\r\n```" ]

[]

[]

[ "> I don't have the faintest idea of how query objects work under the hood, so I don't know if there's a way of extending some class to override this kind of behavior.\r\n\r\nI'd suggest you take a deep dive into the code if you're considering implementing this kind of logic with peewee.\r\n\r\nSQLite has a neat feature called \"ATTACH\" where you can attach different database files and access them, much like you might use separate schemas in Postgresql. Peewee supports this, though you'll need to do some work to reuse the same models across multiple schemas.\r\n\r\nQuery objects are just thin wrappers over cursor objects." ]

[]

[]

[ "Is there a reason you're using a subquery? It seems to me that this is totally unnecessary. You can just write this, which is equivalent to what you have:\r\n\r\n```python\r\nquery = (Issue\r\n .select(Issue, Magazine, Post, User, Stage)\r\n .join_from(Issue, Magazine)\r\n .join_from(Issue, Post, JOIN.LEFT_OUTER)\r\n .join_from(Post, User)\r\n .join_from(Post, Stage)\r\n .where(Issue.id == where['id']))\r\n .order_by(Stage.sort)\r\n```\r\n\r\nAlso note that I'm not calling \".get()\" with the above, because it will return multiple rows (one for each post associated w/the issue).\r\n\r\nRegarding your example, I think the immediate problem may be that you are selecting all the columns of the `Post` model, but that is actually a separate reference from the columns that will be projected from your subquery. Additionally you are referencing \"Post.issue_id\" but your alias is \"Posts\":\r\n\r\n```python\r\n posts = (Posts\r\n .select(Post.issue_id, User, Stage)\r\n # Should be:\r\n posts = (Posts\r\n .select(Posts.issue_id, User, Stage)\r\n```\r\n\r\nThe other issue is you have a call to `.get()`. This will only retrieve a single row of data, so you will not get a list of posts but only a single one.\r\n\r\nThe thing to remember is if you're trying to fetch multiple posts for a single issue, you need to either do it in 2 queries, or accept that the issue/magazine data will be duplicated for each post. Executing the queries in the db shell may make this more clear / easier to see.\r\n\r\nFor example, this is the proper way to reference a subquery's columns in the outer query:\r\n\r\n```python\r\n\r\n# Because you are putting this in a subquery, you need to give all the columns\r\n# you are selecting unique names (to differentiate user \"id\" from stage \"id\").\r\nposts = (Post\r\n .select(Post.issue_id, User.id.alias('user_id'), Stage.id.alias('stage_id'))\r\n .join(User)\r\n .join_from(Post, Stage)\r\n .alias('posts'))\r\n\r\n# This query will contain all columns from issue and magazine, plus some of the columns\r\n# that are selected as part of the sub-query. Although you're only requesting a single Issue,\r\n# there will be as many rows as there are posts, which means you need to deduplicate the data.\r\nquery = (Issue\r\n .select(Issue, Magazine, posts.c.issue_id, posts.c.user_id, posts.c.stage_id)\r\n .join(Magazine)\r\n .join_from(Issue, posts, on=(Issue.id == posts.c.issue_id))\r\n .where(Issue.id == where['id']))\r\n```\r\n\r\nAs a last alternative, I think what you really want is \"prefetch()\". Check out [the docs on the n+1 problem](http://docs.peewee-orm.com/en/latest/peewee/relationships.html#avoiding-the-n-1-problem)." ]

[]

[]

[ "Yea, the way peewee detects \"dirty\" fields is based on observing `__set__` on a descriptor, so it's not perfect in the sense that it actually keeps track of initial state and does a comparison at `save()`-time. You are free to subclass and extend the `Model` behavior to track state more thoroughly, but at present I consider this to be a known limitation." ]

[]

[]

[ "If you're storing a byte array -- i.e., *not* UTF8-encoded text -- you should be using a `BlobField`.", "@coleifer Thank you for your help! I've almost got it working with 'Blobfield'. " ]

[]

[]

[ "Your best bet is to simply add the following before you create the tables:\r\n\r\n```python\r\n\r\ndef setup_schema():\r\n with db:\r\n db.execute_sql('create sequence if not exists \"sequence_name\" start with 10000')\r\n db.create_tables([Foo, Bar, Baz, etc])\r\n```", "You can always do something like this, too:\r\n\r\n```python\r\nclass MyAutoField(AutoField):\r\n def __init__(self, *a, **k):\r\n super(MyAutoField, self).__init__(sequence='the_sequence', *a, **k)\r\n```\r\n\r\nAnd use `id = MyAutoField()` in your models.", "As I understand this code raises an exception for postgresql if you create a table. Too many default values for field or something like this. Should be `IntegerField` instead of `AutoField` and add `primary_key=True` for arguments.\r\nIf you suggest another way would be great!", "Ah, thanks for the clarification. Yes, using `IntegerField(sequence='...', primary_key=True)` should do the trick." ]

[]

[]

[ "For now the easiest way may be:\r\n\r\n```python\r\nclass Taxonomy(Model):\r\n name = CharField()\r\n # ...\r\n\r\n class Meta:\r\n indexes = [\r\n SQL('create index on taxonomies_names (lower(name) varchar_pattern_ops...'),\r\n ]\r\n```\r\n\r\nAlternatively, you can:\r\n\r\n```python\r\n\r\nfrom peewee import NodeList\r\n\r\nname = NodeList((fn.LOWER(Taxonomy.name), SQL('varchar_pattern_ops')))\r\nindex = (Taxonomy\r\n .index(name, Taxonomy.name_class)\r\n .where(Taxonomy.name_class == 'scientific name'))\r\nTaxonomy.add_index(index)\r\n```\r\n\r\nThe above will result in:\r\n\r\n```python\r\nCREATE INDEX \"taxonomy_name_class\" ON \"taxonomy\" (\r\n LOWER(\"name\") varchar_pattern_ops, \"name_class\"\r\n) WHERE (\"name_class\" = 'scientific name');\r\n```\r\n\r\nDocs:\r\n\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#Model.index\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#Model.add_index\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#ModelIndex" ]

[]

[]

[ "Is there a reason you are using \".raw()\"? You could very easily write your second example as:\r\n\r\n```python\r\nPerson.select(Person.name, Value('aaa').alias('field1')).where(Person.id == 1)\r\n```\r\n\r\nI'm not sure why `%s as field1` wouldn't work. What error are you receiving? What database are you using?", "Aha, I see the problem. The documentation also reveals the issue: http://docs.peewee-orm.com/en/latest/peewee/api.html#Model.raw\r\n\r\n`Model.raw()` accepts the query parameters as `*args`, not as a tuple of arguments. So you can fix the problem:\r\n\r\n```python\r\nPersonModel.raw(\"select name, %s as field1 from person where id=%s\", \"aaa\", 1)\r\n```", "Thank you!!\r\nI lose my mind!!〣( ºΔº )〣 " ]

[]

[]

[ "> Although we have written a decorator to explicitly call close on db connections after each call. There are instances when it remains open.\r\n\r\nThis sounds like you have a bug in your code or there is some problem in your environment. I'd strongly suggest you look into where and how you're leaking database connections. As a result, any of the mitigation strategies proposed are going to be hacks.", "Given the leaky connections, perhaps you should not use the pool?", "Making connections evertime is really heavy in google cloud, because of all the auth in place i guess. So no pooling is not an option. We are actively checking for the bugs, it works for most part but overtime we face this issue.\r\n\r\nBut is there anyway I can push the connections from _in_use to the usable pool?", "The entire code for the connection pooling implementation is ~150 lines of code, so I'm sure if you take the time to read and understand it you will be able to subclass/extend it to more aggressively handle your unclosed connections.", "I've added the requested feature:\r\n\r\n* 22e8557e279f5174053ed711f342da8e03fae0c4\r\n* c985636ca13bf8b712d37bf991ece8fdb9a022a8" ]

[]

[]

[ "The `estimatedRows` struct field was added in SQLite 3.8.2. Apparently CentOS 7 ships with some old-as-fuck SQLite and that's causing the problem.", "I know lots of folks like to ship an embedded sqlite with the software? maybe that's an option?", "Unfortunately, Peewee's SQLite C extension utilizes the `estimatedRows` struct field to try and provide hints to the query planner in the virtual table `TableFunction` implementation, so it cannot simply be omitted from the struct definition.\r\n\r\nI think your options are:\r\n\r\n* Use a newer SQLite3\r\n* Do not compile the SQLite C extensions (`export NO_SQLITE=1` should do the trick).", "> I know lots of folks like to ship an embedded sqlite with the software\r\n\r\nThat's not an attractive option for a project like this. You are welcome to create a separate package which includes a SQLite3 along with Peewee, of course." ]

[]

[]

[ "The same issue here, but on different system. I think it's due to the https://github.com/coleifer/peewee/blob/master/setup.py#L12, which's now always `True`, and native extensions are always built. @coleifer can it be made tweakable?", "The same isssue i guees w/ CentOS 7.5 and python 2.7\r\n\r\n```\r\nCollecting peewee\r\n Using cached https://files.pythonhosted.org/packages/2c/08/b059dd7cc0fa6ae45af86f36660fb0838463390d5626d37b8595e54efd9e/peewee-3.6.1.tar.gz\r\nInstalling collected packages: peewee\r\n Running setup.py install for peewee: started\r\n Running setup.py install for peewee: finished with status 'error'\r\n Complete output from command /usr/bin/python2 -u -c \"import setuptools, tokenize;__file__='/tmp/pip-install-ZJ06Kr/peewee/setup.py';f=getattr(tokenize, 'open', open)(__file__);code=f.read().replace('\\r\\n', '\\n');f.close();exec(compile(code, __file__, 'exec'))\" install --record /tmp/pip-record-YKZ06B/install-record.txt --single-version-externally-managed --compile:\r\n running install\r\n running build\r\n running build_py\r\n creating build\r\n creating build/lib.linux-x86_64-2.7\r\n copying peewee.py -> build/lib.linux-x86_64-2.7\r\n copying pwiz.py -> build/lib.linux-x86_64-2.7\r\n creating build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/signals.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/dataset.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/sqliteq.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/apsw_ext.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/reflection.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/flask_utils.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/mysql_ext.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/pool.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/sqlite_udf.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/shortcuts.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/kv.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/migrate.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/db_url.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/__init__.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/sqlite_ext.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/fields.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/test_utils.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/sqlcipher_ext.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/hybrid.py -> build/lib.linux-x86_64-2.7/playhouse\r\n copying playhouse/postgres_ext.py -> build/lib.linux-x86_64-2.7/playhouse\r\n running build_ext\r\n building 'playhouse._speedups' extension\r\n creating build/temp.linux-x86_64-2.7\r\n creating build/temp.linux-x86_64-2.7/playhouse\r\n gcc -pthread -fno-strict-aliasing -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -m64 -mtune=generic -D_GNU_SOURCE -fPIC -fwrapv -DNDEBUG -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -m64 -mtune=generic -D_GNU_SOURCE -fPIC -fwrapv -fPIC -I/usr/include/python2.7 -c playhouse/_speedups.c -o build/temp.linux-x86_64-2.7/playhouse/_speedups.o\r\n gcc -pthread -shared -Wl,-z,relro build/temp.linux-x86_64-2.7/playhouse/_speedups.o -L/usr/lib64 -lpython2.7 -o build/lib.linux-x86_64-2.7/playhouse/_speedups.so\r\n building 'playhouse._sqlite_udf' extension\r\n gcc -pthread -fno-strict-aliasing -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -m64 -mtune=generic -D_GNU_SOURCE -fPIC -fwrapv -DNDEBUG -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -m64 -mtune=generic -D_GNU_SOURCE -fPIC -fwrapv -fPIC -I/usr/include/python2.7 -c playhouse/_sqlite_udf.c -o build/temp.linux-x86_64-2.7/playhouse/_sqlite_udf.o\r\n gcc -pthread -shared -Wl,-z,relro build/temp.linux-x86_64-2.7/playhouse/_sqlite_udf.o -L/usr/lib64 -lpython2.7 -o build/lib.linux-x86_64-2.7/playhouse/_sqlite_udf.so\r\n building 'playhouse._sqlite_ext' extension\r\n gcc -pthread -fno-strict-aliasing -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -m64 -mtune=generic -D_GNU_SOURCE -fPIC -fwrapv -DNDEBUG -O2 -g -pipe -Wall -Wp,-D_FORTIFY_SOURCE=2 -fexceptions -fstack-protector-strong --param=ssp-buffer-size=4 -grecord-gcc-switches -m64 -mtune=generic -D_GNU_SOURCE -fPIC -fwrapv -fPIC -Iplayhouse -I/usr/include/python2.7 -c playhouse/_sqlite_ext.c -o build/temp.linux-x86_64-2.7/playhouse/_sqlite_ext.o\r\n playhouse/_sqlite_ext.c: В функции «__pyx_f_9playhouse_11_sqlite_ext_pwBestIndex»:\r\n playhouse/_sqlite_ext.c:5104:25: предупреждение: несовместимый тип указателя в присваивании [по умолчанию включена]\r\n __pyx_v_pConstraint = (&(__pyx_v_pIdxInfo->aConstraint[__pyx_v_i]));\r\n ^\r\n playhouse/_sqlite_ext.c:5267:23: ошибка: «sqlite3_index_info» не содержит элемента с именем «estimatedRows»\r\n __pyx_v_pIdxInfo->estimatedRows = 10;\r\n ^\r\n playhouse/_sqlite_ext.c:5296:23: ошибка: «sqlite3_index_info» не содержит элемента с именем «estimatedRows»\r\n __pyx_v_pIdxInfo->estimatedRows = __Pyx_pow_long(10, ((long)(__pyx_v_nParams - __pyx_v_nArg)));\r\n ^\r\n playhouse/_sqlite_ext.c:5407:21: ошибка: «sqlite3_index_info» не содержит элемента с именем «estimatedRows»\r\n __pyx_v_pIdxInfo->estimatedRows = 0x186A0;\r\n ^\r\n playhouse/_sqlite_ext.c: В функции «__pyx_f_9playhouse_11_sqlite_ext_18_TableFunctionImpl_create_module»:\r\n playhouse/_sqlite_ext.c:5608:33: предупреждение: несовместимый тип указателя в присваивании [по умолчанию включена]\r\n __pyx_v_self->module.xConnect = __pyx_f_9playhouse_11_sqlite_ext_pwConnect;\r\n ^\r\n playhouse/_sqlite_ext.c: В функции «__pyx_pf_9playhouse_11_sqlite_ext_16ConnectionHelper_8set_update_hook»:\r\n playhouse/_sqlite_ext.c:16587:5: предупреждение: в передаче аргумента 2 «sqlite3_update_hook»: несовместимый тип указателя [по умолчанию включена]\r\n (void)(sqlite3_update_hook(__pyx_v_self->conn->db, __pyx_f_9playhouse_11_sqlite_ext__update_callback, ((void *)__pyx_v_fn)));\r\n ^\r\n In file included from playhouse/_sqlite_ext.c:594:0:\r\n /usr/include/sqlite3.h:4826:18: замечание: expected «void (*)(void *, int, const char *, const char *, sqlite3_int64)» but argument is of type «void (*)(void *, int, char *, char *, sqlite3_int64)»\r\n SQLITE_API void *sqlite3_update_hook(\r\n ^\r\n playhouse/_sqlite_ext.c: В функции «__pyx_pf_9playhouse_11_sqlite_ext_16ConnectionHelper_10set_busy_handler»:\r\n playhouse/_sqlite_ext.c:16699:115: предупреждение: приведение к типу указателя от целого другого размера [-Wint-to-pointer-cast]\r\n (void)(sqlite3_busy_handler(__pyx_v_self->conn->db, __pyx_f_9playhouse_11_sqlite_ext__aggressive_busy_handler, ((void *)__pyx_v_n)));\r\n ^\r\n playhouse/_sqlite_ext.c: В функции «__pyx_f_9playhouse_11_sqlite_ext__aggressive_busy_handler»:\r\n playhouse/_sqlite_ext.c:18629:26: предупреждение: приведение указателя к целому другого размера [-Wpointer-to-int-cast]\r\n __pyx_v_busyTimeout = ((int)__pyx_v_ptr);\r\n ^\r\n playhouse/_sqlite_ext.c: На верхнем уровне:\r\n playhouse/_sqlite_ext.c:6582:18: предупреждение: «__pyx_f_9playhouse_11_sqlite_ext_validate_and_format_datetime» определена, но нигде не используется [-Wunused-function]\r\n static PyObject *__pyx_f_9playhouse_11_sqlite_ext_validate_and_format_datetime(PyObject *__pyx_v_lookup, PyObject *__pyx_v_date_str) {\r\n ^\r\n error: command 'gcc' failed with exit status 1\r\n \r\n ----------------------------------------\r\n```", "Try:\r\n\r\n```\r\nexport NO_SQLITE=1\r\npip install peewee\r\n```\r\n\r\nThis will ensure that the SQLite C extensions are not built. They depend on `libsqlite3` and the `sqlite3.h` header file, which you appear not to have installed on your system. Previously, these extensions would only be built if you also had Cython, but since in 3.6 I've added the pre-generated C files to the package, the extensions will be built.\r\n\r\nThere's a bit of info here regarding the SQLite C extensions: http://docs.peewee-orm.com/en/latest/peewee/installation.html#skip-compilation-of-sqlite-extensions\r\n\r\nI may have to revise the build if this is problematic for a lot of users, however.", "I'm planning a new release, 3.6.2, which will use `ctypes.util.find_library` to determine ahead-of-time if `libsqlite3` is installed. If it is not found, the SQLite extensions will not be built. This should make it no longer necessary to use the above environment variable.", "BTW if anyone has a better suggestion for determining if sqlite3 is available, I'm open to ideas. For example, testing compilation of a very minimal C file?", "Released 3.6.2 -- hopefully this addresses the issue. Please chime in with comments if you are still experiencing problems after upgrading to 3.6.2 and I will re-open the issue.", "@coleifer there are environments when there's no c compiler installed, so I'd check for this first. For me it failed because it tried to look for python headers, which are not installed as well", "> so I'd check for this first.\r\n\r\nHow would you go about testing for the absence of a C compiler?\r\n\r\n**Edit**: added here 9bc4547", "Latest release is now 3.6.3. Includes test for existence of C compiler as well as a subsequent check for the existence of `libsqlite3`. Please let me know if you encounter issues.", "@coleifer it still tries to build `_speedups` extension and fails:\r\n<img width=\"1061\" alt=\"screen shot 2018-07-18 at 19 27 43\" src=\"https://user-images.githubusercontent.com/2615950/42897672-00100604-8ac1-11e8-8215-0452fdc9d079.png\">\r\n", "@lyssdod -- is there a reason you cannot install the Python headers? Typically it's a package called `python-dev`.", "Yes, I know. The reason is I'm using `pip download` to download packages and install them later, and the target system is kind of embedded environment, which doesn't have headers installed", "Hi, I'm also encountering the issue mentioned here on release 3.6.3. I'm using Python 3.5 on Ubuntu 16.04 Xenial, and I have the latest version of `python-dev` available, and have a c-compiler installed. Attempting to install in a clean environment causes the same issue.\r\n\r\nAdding `NO_SQLITE=True` does allow me to install 3.6.3.", "Alright...I think I finally have a solution that should work for everyone. Pushed a new release, 3.6.4, which contains the changes.\r\n\r\nI've changed approaches and now am using an approach similar to what `simplejson` does. First we'll try to build the extensions (assuming we're on CPython and not pypy or something), and if that fails we fall-back to a pure-python build.\r\n\r\nThis should fix the (admittedly baffling to me) situation where you have installed both Python *and* a C compiler, but not the header files.", "@madelyneriksen -- what traceback are you seeing, an error about missing \"sqlite3.h\"? What do you get when you run:\r\n\r\n```python\r\n>>> from ctypes.util import find_library\r\n>>> find_library('sqlite3')\r\n```", "@coleifer Yep, the traceback was about \"sqlite3.h\".\r\n\r\nHere's the output from that Python Session:\r\n```\r\n>>> from ctypes.util import find_library\r\n>>> find_library('sqlite3')\r\n'libsqlite3.so.0'\r\n```\r\n\r\nI just tried installing version 3.6.4 to a new environment, and it works perfectly. The issue on my system regarding headers seems resolved. Thank you!", "Sure thing, thanks for verifying that @madelyneriksen -- I had mistakenly assumed that the presence of the shared library would mean that the headers would be available also (for sqlite). At any rate, the fix in 3.6.4 should resolve the issue. If you wish to build the C extensions, you'll want to install the `libsqlite3-dev` package (which should include sqlite3.h).", "@coleifer Thanks, it works as expected now!", "Hey, guys :D\r\nSorry for being late, but I ask you please to add these dependencies to some doc 'cause it was time consuming to find it in 2023.\r\n\r\nlibsqlite3-dev\r\ncython\r\n\r\nThanks for you hard work.", "Those shouldn't be hard dependencies - they are optional for the extensions.", "That's fine, this is not the right place for this.\r\nSorry 😬 " ]

[]

[]

[ "It is removed because I am no longer interested in maintaining it. Feel free to take the 2.x code and modify it and release it as a separate library." ]

[]

[]

[ "This is way outside the scope of Peewee. Depending on the database driver you are using, you may want to discuss with them, but I doubt you'll have any luck there either. Why you would ever want to pipe a db connection over SSH is a whole other question.\r\n\r\nYou can use the connection pool, which keeps connections open and recycles them -- this may be the best option for you. http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#pool", "Thank you for the reply, I though this would actually matter for the project, but I'll try my luck with the mylsq driver we use.\r\n\r\n> Why you would ever want to pipe a db connection over SSH is a whole other question.\r\nWould you suggest an alternative to avoid exposing the database and still allow peewee to connect?", "> Would you suggest an alternative to avoid exposing the database and still allow peewee to connect?\r\n\r\nPresumably your application server and database server would be on a LAN and only the application server would be exposed to the internet? I've never, in my career, found it necessary to expose a database server to the public internet." ]

[]

[]

[ "Your model class does not appear to have declared a database:\r\n\r\n```python\r\nclass MyModel(Model):\r\n class Meta:\r\n database = ... # You are missing this.\r\n```", "> Your model class does not appear to have declared a database:\r\n> \r\n> ```python\r\n> class MyModel(Model):\r\n> class Meta:\r\n> database = ... # You are missing this.\r\n> ```\r\n\r\nI am facing the same issue and database is defined in Meta. Could you please suggest a fix for this please?", "Share your code", "My apologies, I did a terrible mistake while writing the code. Instead of passing database instance under table's META, I was passing database name itself and hence this issue. But I must say the error \"'NoneType' object has no attribute 'safe_create_index'\" is not developer friendly. It should elaborate more to help us. It took around 1 full day for me to identify this mistake in code.\r\nThanks for your response, you may close this." ]

[]

[]

[ "Whoops, oversight on my part. I need to change the underlying field type to `BigIntegerField`. Will have a patch up shortly.", "3b89d3af132d06f986642384ffbdadfcffbfa563" ]

[]

[]

[ "> I have seen the other closed issue with modulo and percents and understand how psycopg2 binds params.\r\n\r\nMy guess is that the problem is with the way the parameters are interpolated into the SQL string. If you understand this, then it is hopefully clear why this column name was problematic.\r\n\r\nI agree the Peewee error isn't too helpful but in the 8 years I've maintained this project I've never seen anyone use a \"%\" character in a column and report a problem. So I'm going to leave the code as-is. I'd suggest you stick to well-known conventions for naming your tables and columns.\r\n\r\nhttps://launchbylunch.com/posts/2014/Feb/16/sql-naming-conventions/", "Furthermore this isn't a Peewee problem, as much as it is a problem with Python strings interacting with percent signs. Peewee's introspection will detect the weird column name and use a valid Python identifier, so the introspector works correctly in my opinion." ]

[]

[]

[ "I'm going to pass on this for now, but may reconsider adding this functionality (if it can be added cleanly for all supported database implementations). Thank you -- I may end up implementing this at some point and your code will certainly come in handy.", "Also, for what it's worth, if you want to increase the likelihood of getting a \"new feature\" patch merged, it should have tests and documentation as well.", "This is actually now implemented by 273008413737ff16d26b27f846a315cdf4875615\r\n\r\nAlthough it will generate both regular tables *and* views if passed the `-v` option. There is no option to *just* generate views." ]

[]

[]

[ "Thanks. So you can't raise `StopIteration` inside a generator according to [this PEP](https://www.python.org/dev/peps/pep-0479/)... weird. I'm guessing this is some consequence from the asyncio abomination. \r\n\r\n> Currently, StopIteration raised accidentally inside a generator function will be interpreted as the end of the iteration by the loop construct driving the generator.\r\n\r\nWhat if it's raised *intentionally* though? @gvanrossum needs to **sit the fuck down**, I'm glad he's taking his seat and backing off...so many terrible PEPs in the last couple versions.", "Merged, thanks again for taking the time to investigate and fix." ]

[]

[]

[ "http://docs.peewee-orm.com/en/latest/peewee/contributing.html#bugs\r\n\r\nI have literally no clue what you are asking.", "```\r\ntry:\r\n\ttable_name.function_name(...)\r\nexcept IntegrityError as e:\r\n\treturn e\r\n```", "You can do this:\r\n\r\n```python\r\ntry:\r\n SomeModel.function_name(...)\r\nexcept IntegrityError as exc:\r\n exc_message = str(exc)\r\n```" ]

[]

[]

[ "If you want to do something like that, why not just add a property?\r\n\r\n```python\r\n\r\nclass Person(Model):\r\n name = TextField()\r\n \r\n @property\r\n def account(self):\r\n return self.accounts.get()\r\n\r\n @account.setter\r\n def account(self, account_obj):\r\n account_obj.person = self\r\n account_obj.save(only=[Account.person])\r\n\r\nclass Account(Model):\r\n person = ForeignKeyField(Person, backref='accounts', unique=True)\r\n```", "Why was this ticket closed? Is discussion not an option?\r\n\r\nI would expect an ORM to be able to load both records at the same time. I have to run queries against +50,000 records. I will have 6-12 1:1 tables. This will require 100,000s of more queries when all the related row data could be loaded in a single query.\r\n", "Sorry, I assumed I had answered your question. Have you read these documents:\r\n\r\n* http://docs.peewee-orm.com/en/latest/peewee/relationships.html#selecting-from-multiple-sources\r\n* http://docs.peewee-orm.com/en/latest/peewee/relationships.html#avoiding-the-n-1-problem\r\n\r\nAssuming you have, you could then modify your code, using my example models:\r\n\r\n```python\r\nclass Person(Model):\r\n name = TextField()\r\n\r\nclass Account(Model):\r\n person = ForeignKeyField(Person, backref='accounts', unique=True)\r\n account_data = TextField()\r\n\r\nquery = (Person\r\n .select(Person, Account)\r\n .join(Account, JOIN.LEFT_OUTER, attr='account') # To get people w/no account\r\n .order_by(Person.name))\r\n# This is efficiently done in a single query:\r\nfor person in query:\r\n print(person.name, person.account.account_data)\r\n```\r\n\r\n> I would expect an ORM to be able to load both records at the same time\r\n\r\nYes, the docs explain this. Check out the links.", "If I switch unique=True to primary_key=True for the person ForeignKeyField in the Account model in your example I get the behaviour I mentioned originally.", "> If I switch unique=True to primary_key=True for the person ForeignKeyField in the Account model in your example I get the behaviour I mentioned originally.\r\n\r\nI'd be careful about that, you may want to [enable query logging](http://docs.peewee-orm.com/en/latest/peewee/database.html#logging-queries) to make sure your assumptions are indeed correct.\r\n\r\n```python\r\n# Print all queries to stderr.\r\nimport logging\r\nlogger = logging.getLogger('peewee')\r\nlogger.addHandler(logging.StreamHandler())\r\nlogger.setLevel(logging.DEBUG)\r\n```", "I'm not sure what assumptions I would be making here. Using your example, except with primary_key=True instead of unique=True I get the following error:\r\n\r\n`AttributeError: 'ModelSelect' object has no attribute 'account_data'`\r\n\r\nWhich makes sense since account is returned as a ModelSelect instead of the model itself.", "When you access the related object, you should not be using the `backref` attribute -- which is a `ModelSelect` -- but assign the related object to a different attribute as I did in my example.\r\n\r\nPlease look closely at the example:\r\n\r\n```python\r\nclass Person(Model):\r\n name = TextField()\r\n\r\nclass Account(Model):\r\n person = ForeignKeyField(Person, backref='accounts', unique=True)\r\n account_data = TextField()\r\n\r\nquery = (Person\r\n .select(Person, Account)\r\n .join(Account, JOIN.LEFT_OUTER, attr='account') # To get people w/no account\r\n .order_by(Person.name))\r\n# This is efficiently done in a single query:\r\nfor person in query:\r\n print(person.name, person.account.account_data)\r\n```\r\n\r\nIn the above, `person.accounts` (with an \"s\") is a select query. But `person.account`, which is the attribute we specified in the `.join(..., attr='account')`, should hold the joined `Account` instance.", "Here is a complete example. This should hopefully clarify whatever it is you're confused by:\r\n\r\n```python\r\nfrom peewee import *\r\n\r\ndb = SqliteDatabase(':memory:')\r\n\r\nclass BaseModel(Model):\r\n class Meta:\r\n database = db\r\n\r\nclass Person(BaseModel):\r\n name = TextField()\r\n\r\nclass Account(BaseModel):\r\n person = ForeignKeyField(Person, backref='accounts', primary_key=True)\r\n account_data = TextField()\r\n\r\ndb.create_tables([Person, Account])\r\n\r\np1 = Person.create(name='person-1')\r\nAccount.create(person=p1, account_data='p1 account data')\r\n\r\np2 = Person.create(name='person-2')\r\nAccount.create(person=p2, account_data='p2 account data')\r\n\r\nquery = (Person\r\n .select(Person, Account)\r\n .join(Account, attr='account')\r\n .order_by(Person.name))\r\nfor person in query:\r\n print(person.name, person.account.account_data)\r\n```\r\n\r\nPrints:\r\n\r\n```\r\nperson-1 p1 account data\r\nperson-2 p2 account data\r\n```", "Ok, thanks for that. The issue I was having was that my `backref` property was named \"account\" instead of \"accounts\". This caused the error regardless of whether or not I had `attr` specified in the join.\r\n\r\nHere's the frustration I'm having regarding this (using your example):\r\n\r\n1. I have explicitly defined a one-to-one relationship between 2 tables - the foreign key with primary_key attribute set. Assigning the backref as \"account\" instead of \"accounts\" seams obvious to me.\r\n\r\n`person = ForeignKeyField(Person, backref='account', primary_key=True)`\r\n\r\n2. I have explicitly stated in the select query that I wish to retrieve Person *and* Account:\r\n\r\n`select([Person, Account])`\r\n\r\n3. Finally, I have explicitly specified the join for the select query.\r\n\r\n`.join(Account, JOIN.LEFT_OUTER)`\r\n\r\nI think I made a reasonable assumption that this would work. It is not obvious to me that adding `attr` to the join will enable eager loading - the query is already returning account so why not use it? I understand there is a learning curve to every ORM but I also expect features to be 'discoverable'. Perhaps that is my failing here.", "> I have explicitly defined a one-to-one relationship between 2 tables - the foreign key with primary_key attribute set. Assigning the backref as \"account\" instead of \"accounts\" seams obvious to me.\r\n\r\nPeewee does not support the special-case of a one-to-one backref. Thus, the backref should always be the plural, e.g. \"account**s**\".\r\n\r\nIf you want to expose a singular account reference, then you could:\r\n\r\n```python\r\nclass Person(...):\r\n @property\r\n def account(self):\r\n return self.accounts.get()\r\n```\r\n\r\n> I have explicitly stated in the select query that I wish to retrieve Person and Account\r\n\r\nThis is only necessary if you are selecting the person and wish to also grab their account details in a single query.\r\n\r\n> Finally, I have explicitly specified the join for the select query.\r\n\r\nThis is always how peewee works?\r\n\r\n> Perhaps that is my failing here.\r\n\r\nI think the only failing is that you haven't read the docs on [relationships](http://docs.peewee-orm.com/en/latest/peewee/relationships.html). They are thorough and explain all of the behaviors you seem to be confused about.", "foreignkey doesn't support query expression?\r\ni've tried to use `self.accounts.get(Account.name=='abc')` but it doesn't work", "@dzpt - it works like this:\r\n\r\n```python\r\n\r\nself.accounts.where(Account.name == 'abc').get()\r\n```\r\n\r\nThe backref is just a select query, and can be chained like anything else." ]

[]

[]

[ "You need SQLite compiled with the `json1` extension. Apparently the SQLite you're using does not have it.\r\n\r\n* https://sqlite.org/json1.html\r\n* https://www.sqlite.org/compile.html#_options_to_enable_features_normally_turned_off", "Hello @coleifer , I've tried to compile my own sqlite3.dll but it's still not working.\r\n\r\nI'm following these instructions: https://www.sqlite.org/howtocompile.html#building_a_windows_dll\r\n\r\nI download the sql-amalgamation-XXXX.zip and execute the following in MSVC: `cl sqlite3.c -DSQLITE_ENABLE_JSON1 -link -dll -out:sqlite3.dll`. I drop the compiled dll into C:\\Python36\\DLLs. Is this the location where I'm meant to be copying it to? \r\n\r\nAfter I run my peewee script, I'm now returned with a new error:\r\n\r\n```\r\nTraceback (most recent call last):\r\n File \"system_checker_database_test.py\", line 56, in <module>\r\n System.create_table()\r\n File \"C:\\Python36\\lib\\site-packages\\peewee.py\", line 5529, in create_table\r\n cls._schema.create_all(safe, **options)\r\n File \"C:\\Python36\\lib\\site-packages\\peewee.py\", line 4790, in create_all\r\n self.create_table(safe, **table_options)\r\n File \"C:\\Python36\\lib\\site-packages\\peewee.py\", line 4686, in create_table\r\n self.database.execute(self._create_table(safe=safe, **options))\r\n File \"C:\\Python36\\lib\\site-packages\\peewee.py\", line 2589, in execute\r\n return self.execute_sql(sql, params, commit=commit)\r\n File \"C:\\Python36\\lib\\site-packages\\peewee.py\", line 2574, in execute_sql\r\n cursor = self.cursor(commit)\r\n File \"C:\\Python36\\lib\\site-packages\\peewee.py\", line 2560, in cursor\r\n self.connect()\r\n File \"C:\\Python36\\lib\\site-packages\\peewee.py\", line 2523, in connect\r\n self._state.set_connection(self._connect())\r\n File \"C:\\Python36\\lib\\site-packages\\peewee.py\", line 2790, in _connect\r\n raise ImproperlyConfigured('SQLite driver not installed!')\r\npeewee.ImproperlyConfigured: SQLite driver not installed!\r\n```\r\nI'm not doing something right, so I'm hoping someone here will know. Has anyone else compiled their own sqlite3.dll and executed JSON1 extensions using Peewee?\r\n\r\nIf you need any more information, please let me know.\r\n\r\nEDIT:\r\n\r\nI have tried import sqlite3 into a Python shell, but I was returned with the following traceback:\r\n\r\n```\r\n>>> import sqlite3\r\nTraceback (most recent call last):\r\n File \"<stdin>\", line 1, in <module>\r\n File \"C:\\Python36\\lib\\sqlite3\\__init__.py\", line 23, in <module>\r\n from sqlite3.dbapi2 import *\r\n File \"C:\\Python36\\lib\\sqlite3\\dbapi2.py\", line 27, in <module>\r\n from _sqlite3 import *\r\nImportError: DLL load failed: %1 is not a valid Win32 application.\r\n```\r\n\r\nI compiled my sqlite3.dll in both 64-bit and 32-bit versions of MSVC, so I'm not really sure what I'm doing wrong.", "The reason peewee is saying \"SQLite driver not installed!\" is because it cannot import the Python `sqlite3` module. You apparently did something wrong when building the SQLite library, since the standard lib `sqlite3` module links against the system sqlite.", "@coleifer I fixed the issue by downloading the 32-bit version of Python. Now I need to figure out how to make a 64-bit sqlite3.dll." ]

[]

[]

[ "Peewee's main module `peewee.py` defines a module-level `__all__` which controls what is exported when you `import *`. Peewee uses the convention of `import *` internally, so I am going to pass on this change, even though I do understand your reasoning behind the suggestion." ]

[]

[]

[ "I do not plan on implementing such an API, but the fundamentals are all there already.\r\n\r\nYou can use `database.get_tables()` and `database.get_columns()` and check for differences with `Model._meta.fields`. You can also use the higher-level `reflection` APIs.\r\n\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#Database.get_tables\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#Database.get_columns\r\n* http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#reflection", "I put this little function together:\r\n\r\n```python\r\nfrom collections import namedtuple\r\n\r\nfrom playhouse.reflection import Introspector\r\n\r\n\r\nValidationResult = namedtuple('ValidationResult', (\r\n 'valid', 'table_exists', 'add_fields', 'remove_fields', 'change_fields'))\r\n\r\n\r\ndef validate_schema(model):\r\n db = model._meta.database\r\n table = model._meta.table_name\r\n if not db.table_exists(table):\r\n return ValidationResult(False, False, None, None, None)\r\n\r\n introspector = Introspector.from_database(db)\r\n db_model = introspector.generate_models(table_names=[table])[table]\r\n\r\n columns = set(model._meta.columns)\r\n db_columns = set(db_model._meta.columns)\r\n\r\n to_remove = [model._meta.columns[c] for c in columns - db_columns]\r\n to_add = [db_model._meta.columns[c] for c in db_columns - columns]\r\n to_change = []\r\n intersect = columns & db_columns # Take intersection and remove matches.\r\n for column in intersect:\r\n field = model._meta.columns[column]\r\n db_field = db_model._meta.columns[column]\r\n if field.field_type != db_field.field_type:\r\n to_change.append((field, db_field))\r\n\r\n is_valid = not any((to_remove, to_add, to_change))\r\n return ValidationResult(is_valid, True, to_add, to_remove, to_change)\r\n```", "Pushed a new branch which contains the above commit (d6cbfd3), which includes this function as well as some basic unit tests. I don't plan on merging this, as it seems like a slippery slope of folks asking for more and more sophisticated difference detection. But it might be useful for those trying to implement something like you described?", "Wow, thanks for the really quick and detailed answer. \r\nI totally understand that this might be an overkill and out of scope of such library to implement every detail properly. \r\nThe example code is helpful, thanks a lot!" ]

[]

[]

[ "peewee==3.5.2\r\nPython 3.6.5", "Oh, the model contained a bad attribute:\r\n```python\r\n assigned_at = peewee.DateTimeField\r\n```\r\n2.10.2 detected this, while 3.5.2 showed this error.\r\nAfter I added the parens, it worked.\r\n\r\nShould I close this issue?", "> 2.10.2 detected this, while 3.5.2 showed this error.\r\n\r\nWhat did 2.10.2 do when this happened?", "Something like \"Unknown field\".", "I think I'm going to leave this as-is for now, as I'm not sure of a clean way to implement this.", "Very unintuitive error message. This issue probably saved me hours of debugging. I did the same thing @mindojo-victor did. Maybe something in `BaseModel.__new__` like this:\r\n```\r\nfor field in dir(cls):\r\n if field.startswith('__'):\r\n pass\r\n if type(getattr(cls, field)) == type:\r\n raise ValueError('Fields must be initialized.')\r\n```\r\n\r\nI could work on PR", "Whoo that was a fun 2 hrs trying to figure out what was wrong -- I was missing the parens after IntegerField\r\n\r\nIs there an easier way to detect this issue in the future?" ]

[]

[]

[ "I'm going to leave it as-is, but you are welcome to subclass `DateTimeTZField` and add whatever validation you want in the appropriate places." ]

[]

[]

[ "As I mentioned, I intend to prefer pymysql as it supports Python 3.x (whereas MySQLdb does not). I've updated the comment and provided a code snippet you can use to explicitly use MySQLdb (when you have both drivers installed for whatever reason)." ]

[]

[]

[ "So `mysql-python` (`MySQLdb`) does not support Python 3, which is why it is no longer preferred. The comment needs to be updated.\r\n\r\nIf you would like to explicitly use a particular driver, it is quite easy:\r\n\r\n```python\r\nimport MySQLdb\r\n\r\nclass MySQLDatabaseCustom(MySQLDatabase):\r\n def _connect(self):\r\n return MySQLdb.connect(db=self.database, **self.connect_params)\r\n```", "[farcepest/MySQLdb1](https://github.com/farcepest/MySQLdb1) has already been abandoned, [PyMySQL/mysqlclient-python](https://github.com/PyMySQL/mysqlclient-python) has perfect Python3 support without losing performance benefit.", "The code snippet I shared should work just fine. Again, peewee will continue to prefer pymysql, but you can always subclass and override the `_connect()` method. It's a bit surprising that you have both drivers installed, as you don't wish to use pymysql.", "Sorry for disturbance.\r\n\r\nI was debugging a issue on production and I installed mycli, then I found that mycli is requiring PyMySQL as its driver and your comment in code.\r\n\r\nSo I thought, hey, I can make a PR, then two problems will be solved.\r\n\r\nIt sounds like a greate idea, right ?:smile:", "No disturbance -- I recognize it's a somewhat opinionated stance and the comment was incorrect, which made it worse. Hope you're able to get things working." ]

[]

[]

[ "Weird, I would think you would only see that if you had cython, but how would you have cython without a c compiler?\r\n\r\nNo wheels.", "Currently peewee is built using distutils, so there's no support for wheels at present." ]