Datasets:

---

akumoth

/

peewee-issues

like 0

[]

[]

[ "Alternatively, row_dict would have to be generated for every row, which could result in a significant slowdown.\r\n\r\nActually, looking over it again, neither this nor the option above will work. The suggestion from the original issue will fail to insert optional fields if the first inserted row doesn't have all optional fields defined, generating row_dict for every row will result in uneven VALUES parameters, which will fail on insert.\r\n\r\nThis could be a decent substitute: \r\n```python\r\nif not have_fields:\r\n fields = list(set().union(*(row.keys() for row in query._iter_rows())))\r\n fields.sort()\r\n have_fields = True\r\n```", "As you pointed out, a bulk insert query cannot have different values clauses as far as I know, so the difference has to be made up at query construction time... I'll give it some thought.", "@coleifer I currently have it running with the above code on L2104 and onwards, passes tests and seems to perform as expected. Basically just builds a fields list using the set of all keys in the dict, only happens once per query, so the performance impact shouldn't be too huge, though it doesn't scale too well for very large insert sets.", "> though it doesn't scale too well for very large insert sets.\r\n\r\nExactly the problem.", "Check out dd0af77a51b660a8804c6c97115f57d9596e54f2 in 3.0a branch.", "Think I'm going to close this one, as it should be resolved (generally) for 3.0a." ]

[]

[]

[]

[]

[]

[ "You don't have the \"icu\" tokenizer, as the error states.", "http://site.icu-project.org" ]

[]

[]

[ "Correct:\r\nScheduleDetail.insert_many(sch_details, validate_fields=True).execute(). But another error is raised \"KeyError: '\"scheduleDate\" is not a recognized field.\"\r\n\r\n---\r\n```ScheduleDetail.insert_many(sch_details, validate_fields=False).execute()```, when use validate_fields=False, it said \"AttributeError: 'str' object has no attribute '_sort_key'\"", "Use `boxId` instead of `boxId_id`. Also, did you happen to try this on Peewee 3.0a? Furthermore, `scheduleDate` is not a recognized field, so you should not include it in the `insert_many()` call.", "I used boxId_id instead of boxId, it was because in the before, some errors were raised when created tables, said that something wrong with boxId(The detail error message I forgot.), and then I found in the table, the field changed to 'boxId_id', so I try to use boxId_id, and happen to work.\r\nAnyway, thanks a lot." ]

[]

[]

[ "Yes, this is documented. You can very easily add your own `IntervalField` implementation.\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/models.html#creating-a-custom-field" ]

[]

[]

[ "Documentation changes that pertain only to 3.0a are contained in the 3.0a branch." ]

[]

[]

[ "Cheers!", "Wow, that was fast. Thanks.", "For what it's worth, the peewee exceptions are based on those already documented in the DB-API 2.0 spec. https://www.python.org/dev/peps/pep-0249/#exceptions", "Good to know, thanks for the pointer." ]

[]

[]

[ "You tried using Peewee 3.0a? I checked and it appears to work correctly.", "No, not yet." ]

[]

[]

[ "I'll pass, I'm not even sure what validate schema means, btw." ]

[]

[]

[ "You can use Model.dirty_fields, which tracks changes to fields. Will that work?", "It could work, yes. However in a few functions I'm updating all fields and they all get dirty, even if information does not change.\r\n\r\nSo I ended up writing a function that uses `dict(self._data)` and compares current instance vs what's in the database before saving, and gives me only the fields where data is changed. So I'm doing it on save, and with dirty fields I'd have to move this check to another place.", "Cool, I suppose that works, but if it's comparing against what's in the database then doesn't that introduce both an additional query to each save() *and* a race condition?", "What's a race condition?\r\n\r\nAnd yes, indeed it does, and I'm slightly concerned about it. However in this project I don't expect very heavy use of the database, it should work even with SQLite, and I'm sure that MySQL server will handle much more than this. But if there's another solutio to reliably check changes, and whether the field data is actually different from what it was before, that would be great.", "Well, technically that's what `dirty_fields` is for. If you know which fields you're modifying and *don't* want them to be considered dirty, you can remove the field name from `model_instance._dirty` (a `set`). You can also do `model_instance._dirty.clear()` to reset the dirty fields at run-time. That's what I'd do. Anything more complicated gets pretty hairy.", "Well, as I said, I basically have a web form, which allows user to modify every field of the row. Once commited it updates every field. I will still need to perform comparison with existing data somewhere.", "I don't see what the harm is in saving most of the data in that case, but yea, I hear you.", "There's no harm in saving it, it's the fact that I send notifications when something is updated, and I need to know which fields were changed exactly." ]

[]

[]

[ "```psycopg2.ProgrammingError: op ANY/ALL (array) requires array on right side```\r\n\r\nCan you turn on SQL logging and print out the SQL that causes the problem?\r\n\r\n```python\r\nimport logging\r\nlogger = logging.getLogger('peewee')\r\nlogger.addHandler(logging.StreamHandler())\r\nlogger.setLevel(logging.DEBUG)\r\n```", "Oh wait, no need to, I found the SQL:\r\n\r\n```\r\n SELECT\r\n i.relname, idxs.indexdef, idx.indisunique,\r\n array_to_string(array_agg(cols.attname), ',')\r\n FROM pg_catalog.pg_class AS t\r\n INNER JOIN pg_catalog.pg_index AS idx ON t.oid = idx.indrelid\r\n INNER JOIN pg_catalog.pg_class AS i ON idx.indexrelid = i.oid\r\n INNER JOIN pg_catalog.pg_indexes AS idxs ON\r\n (idxs.tablename = t.relname AND idxs.indexname = i.relname)\r\n LEFT OUTER JOIN pg_catalog.pg_attribute AS cols ON\r\n (cols.attrelid = t.oid AND cols.attnum = ANY(idx.indkey))\r\n WHERE t.relname = %s AND t.relkind = %s AND idxs.schemaname = %s\r\n GROUP BY i.relname, idxs.indexdef, idx.indisunique\r\n ORDER BY idx.indisunique DESC, i.relname;\r\n```\r\n\r\nThis comes down to some difference in how redshift implements the SQL engine, I guess?\r\n\r\nI'd suggest subclassing `PostgresqlDatabase` and overriding the `get_indexes()` method with a working version of the above query. If you find a version that works on both regular postgres *and* redshift please let me know, I'd be happy to update the code.", "@coleifer attempting to do something similar as OP. \r\n\r\nI don't think Redshift really has the concept of indexes in the way that Postgres does\r\n\r\nhttps://www.stitchdata.com/blog/how-redshift-differs-from-postgresql/\r\n\r\n>Redshift doesn't support indexes. Instead, each table has a sort key, which determines how rows are ordered when the data is loaded. When you insert, update, or copy data in a Redshift table, new rows get added to an unsorted region, and are sorted only when the table is vacuumed or deep copied.\r\n\r\nWould it be advantageous to just no-op for `get_indexes()` during redshift? ", "You'll probably want to subclass-and-extend, as redshift is not supported as a first-class database by peewee. It's just happens to speak the postgres protocol and *mostly* works." ]

[]

[]

[ "It seems it's impossible to implement cleanly (`last_insert_rowid` etc) . So a note in the docs about the difference in behavior of `execute()` would be awesome.", "What database engine are you using?", "SQLite", "Yeah sqlite doesn't support the returning clause so you're out of luck." ]

[]

[]

[ "http://docs.peewee-orm.com/en/latest/peewee/models.html#self-referential-foreign-keys", "Thanks a lot, sorry I could not find it myself.", "No worries it's tricky if you aren't sure what to Google for." ]

[]

[]

[ "You can, in the model `Meta`, specify `validate_backrefs = False` to disable validation in 2.x.\r\n\r\nIf you're using 3.0a, validation is not enforced at the moment.\r\n\r\nI had not considered supporting disabling backrefs altogether, but that might be a good idea to add in 3.0a.", "In 3.0a, by specifying `backref='!'`, you can disable the addition of the backref accessor to the related model." ]

[]

[]

[ "In peewee 3.0a you can pass `temporary=True` when calling create_table(). In 2.x you'll need to write the query by hand." ]

[]

[]

[ "You probably need to install psycopg2 the postgres driver." ]

[]

[]

[ "Sure...it's just Python?", "Thanks." ]

[]

[]

[ "I believe you should be fine to use `BlobField` for most things, but it is also very easy to subclass `BlobField` and provide an implementation for the data-type you wish to use.\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/models.html#creating-a-custom-field" ]

[]

[]

[ "https://github.com/coleifer/peewee/issues/630" ]

[]

[]

[ "Somehow I assume your dataService() object is not getting instantiated. There is a problem in your python code, not in Peewee.", "Hello, I checked my code again and found that the error `OperationalError: Database has not been initialized` just thrown when I was trying to `from model import db`. \r\nSo how could I import `db` without this error? ( Since my variable `db` and class `dataService` defined in two seperate files)" ]

[]

[]

[ "What would it create if there were no columns defined?", "it could just create a table with an id column by default", "And what if you don't want the \"id\" column? Seems weird.", "`migrator.create_table('users', pk='user_id'),` \r\n", "Peewee already has APIs for creating tables -- going to pass on these suggestions." ]

[]

[]

[ "You *should* just be able to write:\r\n\r\n```python\r\nData.select().where(Data.notes['org_path'] % '1/2/*')\r\n# ('SELECT \"t1\".\"id\", \"t1\".\"notes\" FROM \"data\" AS \"t1\" WHERE (\"t1\".\"notes\"->>%s LIKE %s)',\r\n# ['org_chart', '1/2/*'])\r\n```", "Uh, I'll try that. What how about _if_ I actually needed to build something more complex, where I would really face the problems in the original message?", "Can you give an example of a more complex query?", "Maybe using some more exotic json operators (or combination) from https://www.postgresql.org/docs/current/static/functions-json.html. I would assume not everything is supported out-of-box?", "*Most* of that stuff actually is supported, although there are probably some exceptions.\r\n\r\nTo your question, though... The `SQL()` constructor doesn't know about converting models or fields into quoted names. It treats everything after the SQL string itself as a parameter of the query.\r\n\r\nIf you wanted to dynamically construct a query, you might do something like:\r\n\r\n```python\r\n# 2.x\r\nexp = Clause(Data.notes, SQL('->>\"foobar\" LIKE %s', '1/2/*'), glue='')\r\n\r\n# 3.x\r\nexp = NodeList([\r\n Data.notes, \r\n SQL('->>\"foobar\" LIKE %s', ('1/2/*',))\r\n], glue='')\r\n\r\n# either\r\nData.select().where(exp)\r\n```", "Yeah, I see them now in `PostgresqlExtCompiler`. Most of the stuff that is not implemented is probably not needed after all (concat `||` and deletions `-`/`#-`).\r\n\r\nNone of the [JSON Processing Functions](https://www.postgresql.org/docs/current/static/functions-json.html#FUNCTIONS-JSON-PROCESSING-TABLE) are supported, though? Some of those could be useful sometimes (though I'm not sure when/how).", "They are, just use `fn.json_function_name(...)`.", "Of course. Thanks again. `peewee` is awesome." ]

[]

[]

[ "Good catch...the `filter()` API is not very smart when it comes to self-referential foreign-keys. I had thought it would handle this simple case, but apparently I'm missing a unit-test (which would've revealed the issue).\r\n\r\nFor now, try:\r\n\r\n```python\r\nM.get(M.parent == 10000)\r\n```", "I've pushed a fix for this simple case in 3.0a. Unfortunately, lookups that traverse the self-referential FK will still have the join alias issue.", "It works fine! When the 3.0 branch become to stable, I will merge it into our company. Thanks!\r\n\r\nBut sorry, I can't really understand what does `lookups that traverse the self-referential FK will still have the join alias issue` mean. Can you give me a example? I can't reproduce it.\r\n\r\nI've tried this:\r\n\r\n```python\r\nMA = M.alias()\r\nMA.get(parent=10000)\r\n```\r\n\r\nIt still work.", "Or do you mean this?\r\n\r\n```python\r\nquery = M.select().join(M)\r\n\r\nM.execute() # peewee.OperationalError: (1066, \"Not unique table/alias: 't1'\")\r\n```\r\n\r\nIn fact, I always do the alias like your documentation [self-joins](http://peewee.readthedocs.io/en/latest/peewee/querying.html#self-joins)\r\n\r\n```\r\nMA = M.alias()\r\nquery = M.select().join(MA)\r\n\r\nquery.execute()\r\n```\r\n\r\nI think it is good enough, because if I want to specify other conditions, I can do that:\r\n\r\n```python\r\nM.select().join(MA).where(M.name == 'a', MA.name == 'b')\r\n```", "If you are doing a self-join you should always alias it (2nd example using `.join(MA)`).\r\n\r\nThe problem was that when using `.get()` with keyword-arguments, it is using the `.filter()` API under-the-hood, and this API does not cope well with self-referential FKs.\r\n\r\nThe standard APIs work just fine, however.", "I got it, thanks!" ]

[]

[]

[ "Try opening up a python shell and running:\r\n\r\n```\r\nfrom peewee import sqlite3\r\nprint sqlite3\r\n```\r\n\r\nYou can also try:\r\n\r\n```\r\nfrom pysqlite2 import dbapi2\r\nimport sqlite3\r\n```\r\n\r\nWhat happens?", "My python is compiled by myself, I forget to add sqlite3 module." ]

[]

[]

[ "?", "MySQL\r\n\r\n```python\r\nsql = \"select DATE_FORMAT(MAX(NOW()),'%Y-%m-%d'); \"\r\nprint database.execute_sql(sql)\r\n\r\n\r\nsql = \"insert into t_user set name='abc%abc';\"\r\nprint database.execute_sql(sql)\r\n\r\n\r\n```\r\n```\r\nTraceback (most recent call last):\r\n File \"models.py\", line 1332, in <module>\r\n print database.execute_sql(sql)\r\n File \"/usr/lib/python2.6/site-packages/playhouse/shortcuts.py\", line 203, in execute_sql\r\n sql, params, require_commit)\r\n File \"/usr/lib/python2.6/site-packages/peewee.py\", line 3454, in execute_sql\r\n cursor.execute(sql, params or ())\r\n File \"/usr/lib64/python2.6/site-packages/MySQLdb/cursors.py\", line 158, in execute\r\n query = query % db.literal(args)\r\nTypeError: not enough arguments for format string\r\n\r\n```\r\n\r\nhttps://github.com/coleifer/peewee/blob/c6b5946a997e39f9939b0261e2b75c46acbac8f2/peewee.py#L3831\r\n\r\n`params` is None", "Why aren't you parameterizing your query? You should use %s as the placeholder for those params, then pass them in as a tuple:\r\n\r\n```\r\ndb.execute_sql('select date_format(max(now)), %s)', ('%Y-%m-%d'))\r\n```" ]

[]

[]

[ "You might try removing one of the slashes on the sqlite filename.\r\n\r\nIt seems a bit wonky to use `connect` to instantiate a db object, only to throw it away and call `init` on a different instance. I get that you want to use the logic in `connect()` -- but it seems like if you can do it in one place you should be able to do it in the other (e.g. in `models.py`).", "See also:\r\n\r\n* http://docs.peewee-orm.com/en/latest/peewee/database.html#run-time-database-configuration\r\n* http://docs.peewee-orm.com/en/latest/peewee/database.html#dynamically-defining-a-database", "Thanks for the response. How do I do this with a connection string? I'm working in an environment with different database backends on different machines - just Sqlite and PostgreSQL at the moment but I'd like to be able to use others in the future. How can I do this so that I don't have to parse the database config to work out which type of database object to create? \r\n\r\nUsing database URLs is perfect, as long as I can do lazy instantiation at run time.", "> OperationalError: FATAL: database \"/Users/andy47/my_db.sqlite\" does not exist\r\n\r\nWait a sec...is that error occurring because in your models you have `db = PostgresqlDatabase(None)`?", "Could have been, after your advice a couple of comments earlier I've changed this to a `Proxy()` object.", "I'm not sure why you have closed this, I still can't do a lazy instantiation of a database connection based on a connection string.", "```python\r\n\r\ndb = Proxy()\r\n\r\nclass BaseModel(Model):\r\n class Meta:\r\n database = db\r\n\r\n# ... some time later ...\r\nreal_db = connect(connection_string)\r\ndb.initialize(real_db)\r\n```" ]

[]

[]

[ "Peewee 3.0a supports a `Cast` type and corresponding method.\r\n\r\n```python\r\n# untested, but should be about right\r\nquery = MyModel.select().where(Model.json['num'].cast('numeric') >= 100)\r\nprint query.count()\r\n```\r\n\r\nIn Peewee 2.x you can:\r\n\r\n```python\r\nfrom playhouse.shortcuts import cast\r\nquery = MyModel.select().where(cast(Model.json['num'], 'numeric') >= 100)\r\nprint query.count()\r\n```\r\n\r\nAnd yes, you can use these approaches for joining." ]

[]

[]

[ "Could you be more specific?", "I just wanted to switch the schema using class Meta. I went through the docs and achieve it with this:\r\nhttp://docs.peewee-orm.com/en/latest/peewee/models.html#model-options-and-table-metadata" ]

[]

[]

[ "Can you provide an example? I'm not sure I follow about inheriting classes.", "You can disable backref validation by specifying:\r\n\r\n```python\r\nclass MyModel(Model):\r\n class Meta:\r\n validate_backrefs = False\r\n```\r\n\r\nAlso, so long as you aren't explicitly setting the `related_name`, inherited classes would dynamically set it based on the class name:\r\n\r\n```python\r\nclass Foo(Model): pass\r\n\r\nclass Bar(Model):\r\n foo = ForeignKeyField(Foo)\r\n\r\nclass Baz(Bar): pass\r\n\r\n# Foo.bar_set -> related Bar objects\r\n# Foo.baz_set -> related Baz objects\r\n```", "Is this your point?\r\n\r\n```python\r\n# common.py\r\nclass Foo(Model):\r\n pass\r\n\r\nclass Bar(Model):\r\n foo = ForeignKeyField(foo_proxy, related_name='bars')\r\n```\r\n\r\n```python\r\n# sub1.py\r\nclass Foo(common.Foo):\r\n pass\r\n\r\nclass Bar(common.Foo):\r\n pass\r\n```\r\n\r\n```python\r\n# sub2.py\r\nclass Foo(common.Foo):\r\n pass\r\n\r\nclass Bar(common.Bar):\r\n pass\r\n```\r\n", "@coleifer I want the inheriting classes and the base classes to share the same field in the foreign class so that they can all be grouped together. Is that possible? I'm not sure what the backref validation means", "I don't understand what \"foreign class\" means, or \"grouped together\" means?", "```python\r\nclass Foo(Model):\r\n pass\r\n\r\nclass Bar(Model):\r\n foothing = ForeignKeyField(Foo, related_name='bars')\r\n\r\nclass Baz(Bar):\r\n pass\r\n```\r\n\r\nI want both Bar and Baz to be in the bars field of Foo", "```python\r\nclass Foo(Model):\r\n @property\r\n def bars(self):\r\n return [] + self.bar_set + self.baz_set\r\n\r\nclass Bar(Model):\r\n foothing = ForeignKeyField(Foo)\r\n\r\nclass Baz(Bar):\r\n pass\r\n```", "@FireFaced -- that doesn't work how you think it might. `Bar` and `Baz` are two separate tables. The backref (`bars`) is a select query that is pre-filtered.\r\n\r\nSo, for example:\r\n\r\n```python\r\nf = Foo(id=1337)\r\nf.bars # SELECT * FROM bar WHERE foothing_id=1337\r\n```\r\n\r\nThus, a back-ref is limited to a single table. The example from @yanghg-basefx may work but is also inefficient in that it executes 2 queries and coerces to a list, potentially using a lot of memory if the result sets are large.", "So how could I implement it so that I can see all types of Bar? Would I end\nup using a different type of field or something?\n\nOn Mon, Nov 27, 2017, 10:34 Charles Leifer <[email protected]> wrote:\n\n> @FireFaced <https://github.com/firefaced> -- that doesn't work how you\n> think it might. Bar and Baz are two separate tables. The backref (bars)\n> is a select query that is pre-filtered.\n>\n> So, for example:\n>\n> f = Foo(id=1337)\n> f.bars # SELECT * FROM bar WHERE foothing_id=1337\n>\n> Thus, a back-ref is limited to a single table. The example from\n> @yanghg-basefx <https://github.com/yanghg-basefx> may work but is also\n> inefficient in that it executes 2 queries and coerces to a list,\n> potentially using a lot of memory if the result sets are large.\n>\n> —\n> You are receiving this because you were mentioned.\n> Reply to this email directly, view it on GitHub\n> <https://github.com/coleifer/peewee/issues/1390#issuecomment-347218717>,\n> or mute the thread\n> <https://github.com/notifications/unsubscribe-auth/AHwCh-MaJFVflz_OCxRDlei_7sqMiNdjks5s6tZjgaJpZM4QlNgA>\n> .\n>\n", "Well the problem is that if you have two classes you'll end up with two separate tables. That makes sense, right? Depending on how you structure those tables, you could possibly use a UNION query or something, but you're quickly running into problems trying to conflate object-orientation with relational database design." ]

[]

[]

[ "Cheers, thanks!" ]

[]

[]

[ "This kind of question is not appropriate for the issue tracker. Please post to stackoverflow.\r\n\r\nBecause I'm a nice guy :) you're getting duplicate rows because you're joining on Photo...why are you joining on photo in the above query?" ]

[]

[]

[]

[]

[]

[ "I'm confused... Peewee normalizes the case of the table name from the model name in the absence of an explicit `db_table`, so the first call to create_tables() in step 1 should be using the same table name as in step 3.", "This is odd, it appears to be changing the case unpredictably.\r\n\r\nHere is what I am seeing:\r\n\r\nthis is my model (note i am forcing it to downcase on this example)\r\nAt each step I will show the output of `cls._meta.db_table` and `cls._meta.database.get_tables`\r\n\r\n### 1. Initial create_tables (table does not yet exist)\r\n```python\r\nclass KubernetesUser(BaseModel):\r\n ldap_username = TextField()\r\n token = TextField()\r\n uid = TextField()\r\n created_at = DateTimeField()\r\n\r\n class Meta:\r\n db_table = 'kubernetesuser'\r\n```\r\n\r\nI run `create_tables([KubernetesUser], safe=True)`\r\nTable created successfully:\r\n`cls._meta.db_table` = kubernetesuser\r\n`cls._meta.database.get_tables` = []\r\n\r\n### 2. Run create_tables again to show output and verify its working as expected\r\n```python\r\ncreate_tables([KubernetesUser], safe=True)\r\n```\r\n\r\n`cls._meta.db_table` = kubernetesuser\r\n`cls._meta.database.get_tables` = ['kubernetesuser']\r\n\r\n### 3. Run a migration to add a column\r\n```python\r\nmigrate(\r\n migrator.add_column('KubernetesUser', 'token_updated_at', token_updated_at_field)\r\n )\r\n```\r\nColumn is successfully added\r\n\r\n### 4. Run create_tables again\r\n```python\r\ncreate_tables([KubernetesUser], safe=True)\r\n```\r\n\r\n`cls._meta.db_table` = kubernetesuser\r\n`cls._meta.database.get_tables` = ['KubernetesUser']\r\n\r\n***pymysql.err.InternalError: (1050, \"Table 'kubernetesuser' already exists\")***\r\n\r\nIs it the migration causing the table name to be changed?\r\n\r\n", "Yep that seems to be it - the migration is changing the case and the code is always expecting lowercase.. \r\n\r\nbefore migration:\r\nmysql> show tables;\r\n+--------------------------+\r\n| Tables_in_kube_ldap_auth |\r\n+--------------------------+\r\n| kubernetesuser |\r\n+--------------------------+\r\n\r\nafter migration:\r\n+--------------------------+\r\n| Tables_in_kube_ldap_auth |\r\n+--------------------------+\r\n| KubernetesUser |\r\n+--------------------------+\r\n\r\nseems its my fault then for adding case to the table name in the migration.\r\n\r\nKnowing that peewee normalizes the name to lowercase, perhaps the migration code should force lowercase on the table name for migrations to avoid users shooting themselves in the foot like I have.", "Yeah in your migration you need to specify the table name using the same case as the model name. \"kubernetesuser\". That ought to fix ya." ]

[]

[]

[ "The issue is you're selecting a column on a joined model, but not selecting anything from Test_File_Options.\r\n\r\nYou probably want to rewrite as:\r\n\r\n```python\r\n(TestFile\r\n .select(TestFile.filename)\r\n .join(Test_File_Options)\r\n .join(TestOption)\r\n .where(TestOption.option == '-G')\r\n .get())\r\n```" ]

[]

[]

[ "My sense is that this has to do with using server-side cursors, but I couldn't be more specific. A further consideration is that when you iterate over a large list of rows, Peewee will cache the results in memory to make subsequent iterations fast. If you only need to do a single-pass, you can add \".iterator()\" to your query:\r\n\r\n```python\r\ndef run_peewee_query():\r\n query = PeeweePerson.select(PeeweePerson.id).order_by(PeeweePerson.id.desc()).limit(limit)\r\n ids = list(query.iterator().tuples())\r\n return ids\r\n```\r\n\r\nIt's possible that SQLAlchemy may be calling `fetchmany()` or `fetchall()`? I'm not really sure. If the time is being spent in `cursor.fetchone()` then that tells me that any processing in Peewee itself is probably not the cause of the slowness. It might simply be the way peewee is handling the cursor?", "Leaving link to psycopg2 docs for handy reference: http://initd.org/psycopg/docs/usage.html#server-side-cursors", "I tried the iterator (fixed to `list(query.tuples().iterator())`) but found no improvement.\r\n\r\nAs far as I can tell you're right - the cursor is not being handled correctly. I'll continue digging into this.\r\n\r\nFYI also asked this on SO. Ref: https://stackoverflow.com/q/47313869/2533895", "How's the performance when using client-side cursors?", "@coleifer Ok, performance with client-side cursors is great - i should've tried that in the first place.\r\n\r\nDefinitely a bug with the server-side cursor implementation.", "I found this issue, too. I try to use this solution in our company:\r\n\r\n```python\r\nclass QueryResultCursor(object):\r\n def __init__(self, cursor):\r\n super(QueryResultCursor, self).__init__()\r\n self.rows = cursor.fetchall()\r\n self.row_iterator = iter(self.rows)\r\n self.close = cursor.close\r\n self.description = cursor.descrition\r\n self.name = getattr(cursor, 'name', None)\r\n\r\n def fetchone(self):\r\n try:\r\n return self.row_iterator.next()\r\n except StopIteration:\r\n return None\r\n\r\nclass QueryResultWrapper(object):\r\n def __init__(self, model, cursor, meta=None):\r\n self.cursor = QueryResultCursor(cursor)\r\n ...\r\n```\r\n\r\nYes, actually this will fetch all rows at once to memory, and I don't need to change your code any more :)", "But you are right, don't use server-side cursors is a better choice", "I'll see about fixing this for 3.0a.", "@ParthGandhi -- out of curiosity, what version of psycopg2 are you using?", "If you're interested, you might want to try out the latest commit in the 3.0a branch, which has a rewritten server-side implementation: 0ae17c519475c935d9db3c338f36ef058a3f879c", "`psycopg2==2.7.3.2`\r\n\r\nOooh, thanks. Will check that out.", "How'd things go with the new implementation?", "Haven't had a chance to try it out yet - got pulled into other work." ]

[]

[]

[ "Nevermind. I fixed it by running it in one transaction as two separate .raw() queries." ]

[]

[]

[ "Correct. The docs state this:\r\n\r\n> The downside, however, is that you cannot issue write transactions that encompass multiple queries – all writes run in autocommit mode, essentially.\r\n\r\nTo prevent users from shooting themselves in the foot, transaction APIs are disabled.\r\n\r\nThe problem is you're mixing two paradigms for multi-threaded database access. SqliteQ is only suitable for certain classes of problem...specifically, those where writes can be issued in autocommit mode. To do get-or-create you really need a multi-statement transaction... something like SELECT ... FOR UPDATE, which Sqlite doesn't support. It *does* however support the non-standard INSERT OR REPLACE query, which is perfect for get-or-create, as long as you have a constraint in place.\r\n\r\nSo I'd suggest changing your get-or-create to an INSERT OR REPLACE query, enforced by a constraint. Or alternatively do not use SqliteQ.", "ok. Which sqlite engine should I use with my asyncio program (only event loop access to the sqlite file)?", "Oh brother... asyncio is a garbage fire. I have no idea, but definitely not sqliteq.", "why so ?\r\n" ]

[]

[]

[ "Enum is a python 3 thing, using it in 2.x requires a separate library if I'm not mistaken. Similarly, I prefer not to hard-code the list of supported actions since there may be some variance between options between databases (?)." ]

[]

[]

[ "`get_or_create()` is not a silver bullet...race conditions abound.\r\n\r\nYour best bet is to use database constraints (as you are) and do something like select for update or create->get.\r\n\r\n```python\r\nwith db.atomic():\r\n try:\r\n test_file = TestFile.select().where(TestFile.filename == f).for_update().get()\r\n except TestFile.DoesNotExist:\r\n TestFile.create(filename=f)\r\n```\r\n\r\nOr, better, since it seems you'd rather create them:\r\n\r\n```python\r\ntry:\r\n with db.atomic():\r\n TestFile.create(filename=f)\r\nexcept IntegrityError:\r\n pass\r\n```", "Ok, good to know. I went with the latter solution and it seems to be working. Thanks!" ]

[]

[]

[]

[]

[]

[ "https://github.com/coleifer/peewee/issues/178#issuecomment-232955141" ]

[]

[]

[ "This isn't SQLAlchemy, home-skillet!\r\n\r\nGood suggestion on making read-only :+1: ", "So, I just prototyped the change and realized I can't enforce making back-references read-only because under some conditions, when resolving a query, Peewee may assign a list to the backref. For example when calling `dict_to_model`, it's possible to end up assigning a list to the back-reference. Similar goes for `prefetch`." ]

[]

[]

[ "I'm not sure exactly what you mean, but Peewee supports arbitrary function calls:\r\n\r\n```\r\nSomeModel.select().where(fn.soundex(SomeModel.column) == fn.soundex(search_string))\r\n```" ]

[]

[]

[ "I believe this is a PyTest problem. Peewee uses recursive-descent to convert the AST into SQL. Given that it runs fine outside the py.test suite, I'd suggest you file this with the py.test developers.", "@coleifer thanks for the quick response. I found a similar open issue there, I'll follow up with the py.test developers.\r\n\r\nhttps://github.com/pytest-dev/pytest/issues/2724", "Looks like I jumped the gun a little. I was able to recreate this issue using plain unittest, so I dug into it a little further using pdb. The root issue, as far as I can tell, appears to be that calling `self.interpolation` on a JsonLookup object returns itself as a param, leading to the recursion error at line 1894/1899 of parse_node. Why this would only happen during testing I have no idea; I'm pretty new to the Python ecosystem, so I'm not sure if it's doing anything differently when testing. Same thing happens with 2.7 FWIW.\r\n\r\npdb output:\r\n```\r\n(Pdb) s\r\n--Call--\r\n> /Users/chris/Projects/recursion_error/.venv/lib/python3.6/site-packages/peewee.py(1881)parse_node()\r\n-> def parse_node(self, node, alias_map=None, conv=None):\r\n(Pdb) s\r\n> /Users/chris/Projects/recursion_error/.venv/lib/python3.6/site-packages/peewee.py(1882)parse_node()\r\n-> sql, params, unknown = self._parse(node, alias_map, conv)\r\n(Pdb) pp node\r\n<playhouse.postgres_ext.JsonLookup object at 0x1070248d0>\r\n(Pdb)\r\n\r\n...\r\n\r\n(Pdb) s\r\n> /Users/chris/Projects/recursion_error/.venv/lib/python3.6/site-packages/peewee.py(1739)_parse_default()\r\n-> return self.interpolation, [node]\r\n(Pdb) s\r\n--Return--\r\n> /Users/chris/Projects/recursion_error/.venv/lib/python3.6/site-packages/peewee.py(1739)_parse_default()->('%s', [<playhouse.po...t 0x1070248d0>])\r\n-> return self.interpolation, [node]\r\n(Pdb)\r\n\r\n...\r\n\r\n--Return--\r\n> /Users/chris/Projects/recursion_error/.venv/lib/python3.6/site-packages/peewee.py(1879)_parse()->('%s', [<playhouse.po...t 0x1070248d0>], True)\r\n-> return sql, params, unknown\r\n(Pdb) \r\n\r\n...\r\n\r\n(Pdb) s\r\n> /Users/chris/Projects/recursion_error/.venv/lib/python3.6/site-packages/peewee.py(1898)parse_node()\r\n-> if isinstance(param, Node):\r\n(Pdb) s\r\n> /Users/chris/Projects/recursion_error/.venv/lib/python3.6/site-packages/peewee.py(1899)parse_node()\r\n-> csql, cparams = self.parse_node(param)\r\n(Pdb) pp param\r\n<playhouse.postgres_ext.JsonLookup object at 0x1070248d0>\r\n(Pdb) s\r\n--Call--\r\n> /Users/chris/Projects/recursion_error/.venv/lib/python3.6/site-packages/peewee.py(1881)parse_node()\r\n-> def parse_node(self, node, alias_map=None, conv=None):\r\n(Pdb) s\r\n> /Users/chris/Projects/recursion_error/.venv/lib/python3.6/site-packages/peewee.py(1882)parse_node()\r\n-> sql, params, unknown = self._parse(node, alias_map, conv)\r\n(Pdb) pp node\r\n<playhouse.postgres_ext.JsonLookup object at 0x1070248d0>\r\n(Pdb)\r\n```", "I'm confused how something so fundamental could be an issue, as the `BinaryJSONField` is tested extensively in peewee's test suite. Furthermore, it's only happening in the tests?\r\n\r\nCan you add a test-case to Peewee that replicates the issue? See:\r\n\r\nhttps://github.com/coleifer/peewee/blob/f4ebd78b990efc6f0fc57b9a4d81f0cd6ecdf276/playhouse/tests/test_postgres.py#L606-L948", "So, turns out the issue is not with core peewee, but apparently with the playhouse db_url module, or at least how I was using it.\r\n\r\nInitializing the database with:\r\n```\r\n_database = peewee.Proxy()\r\n_database.initialize(connect(\"postgresql://test:test@localhost:5432/test\"))\r\n```\r\nresults in the RecursionError, while everything is fine when doing:\r\n```\r\n_database = peewee.Proxy()\r\n_database.initialize(postgres_ext.PostgresqlExtDatabase('test', user='test', password='test', host='localhost'))\r\n```\r\n\r\nWhether this is an actual problem with db_url or there was something else wrong with my configuration I'm not sure, but definitely an unintuitive error to track down. (Turns out we had been doing it the latter way in the actual project the whole time, which is presumably why the issue only appeared in testing. Whoops.)\r\n\r\nAnyway, thanks again for your time!", "Ahh, you can use the db_url module, but you need to use `postgresqlext` as the protocol.\r\n\r\nhttps://github.com/coleifer/peewee/blob/master/playhouse/db_url.py#L129", "LOL. Yep, that did it. I really appreciate your responsiveness, thanks again." ]

[]

[]

[ "Before I dig into this specific issue, do you mind giving things a try with 3.0a and letting me know if it resolves the issue?", "This appears to be working correctly in the 3.0a branch:\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 Owner(BaseModel):\r\n name = CharField()\r\n\r\nclass Cat(BaseModel):\r\n owner = ForeignKeyField(Owner)\r\n name = CharField()\r\n\r\nclass Rat(BaseModel):\r\n owner = ForeignKeyField(Owner, null=True)\r\n caught_by = ForeignKeyField(Cat, null=True)\r\n name = CharField()\r\n\r\ndb.create_tables([Owner, Cat, Rat])\r\n\r\no1 = Owner.create(name='o1')\r\no2 = Owner.create(name='o2')\r\n\r\nc11 = Cat.create(name='c1-1', owner=o1)\r\nc12 = Cat.create(name='c1-2', owner=o1)\r\nc21 = Cat.create(name='c2-1', owner=o2)\r\n\r\nr11 = Rat.create(name='r1-1', caught_by=c11)\r\nr12 = Rat.create(name='r1-2', caught_by=c12)\r\nr1x = Rat.create(name='r1-x', owner=o2)\r\n\r\nr21 = Rat.create(name='r2-1', caught_by=c21, owner=o2)\r\nr22 = Rat.create(name='r2-2', caught_by=c21)\r\n\r\nquery = (Rat\r\n .select(Rat, Owner)\r\n .join(Cat, JOIN.LEFT_OUTER)\r\n .switch(Rat)\r\n .join(Owner, JOIN.LEFT_OUTER, on=(\r\n fn.COALESCE(Rat.owner, Cat.owner) == Owner.id).alias('_real_owner')))\r\nfor row in query:\r\n print row.name, row._real_owner.__data__\r\n```\r\n\r\nPRINTS:\r\n\r\n```\r\nr1-1 {'id': 1, 'name': u'o1'}\r\nr1-2 {'id': 1, 'name': u'o1'}\r\nr1-x {'id': 2, 'name': u'o2'}\r\nr2-1 {'id': 2, 'name': u'o2'}\r\nr2-2 {'id': 2, 'name': u'o2'}\r\n```" ]

[]

[]

[ "能不能在不同数据库间join并不是peewee能决定的。比如MySQL，同一个服务的不同数据库间是可以join的，但是不同服务就不要想了。\r\n\r\n更明确一点，你定义Model的时候，是用的同一个peewee.Database 实例还是不同的Database实例，这决定了你到底能不能在不同的数据库之间join", "@yanghg-basefx 数据库用的是MYSQL，MYSQL本身是支持cross db join的， 用raw sql是没有问题的；\r\n两个model分别是不同的database属性（_meta.database）。\r\n看了下peewee源码，它确实不支持cross db join，即使用model.select().join()...这样构造出的sql语句在cross db join的情况下是错误的。\r\n请问是否有peewee cross db join的方案？（不使用raw sql）", "哦可能我理解错你的问题了。peewee默认想要用join的话必须有一个 \r\nForeignKeyField，如果没有的话在compile SQL语句的时候会报错。所以如果想要 \r\n用M.select.join()你首先要在他们之间建立一个连接，哪怕是假的连接也行。\r\n\r\n然后，如果你没有指定on条件的话，peewee会根据你的连接自动生成，类似于(ON \r\nM2.m1_id = M1.id)，所以你必须要指定一条一定为True的on条件。\r\n\r\n根据这个原理，我们就可以伪造出一条只能用来CROSS JOIN的语句了。\r\n\r\nclass M1(Model):\r\n\r\n class Meta:\r\n database = MySQLDatabase(**M1_CFG)\r\n db_table ='m1'\r\n\r\n\r\nclass M2(Model):\r\n m1 = ForeignKeyField(M1,'m2s',db_column='id')\r\n\r\n class Meta:\r\n database = MySQLDatabase(**M2_CFG)\r\n db_table ='m2'\r\nfor m2 in M2.select(M2, M1).join(M1,join_type='CROSS JOIN',on=M2.id.is_null(False)):\r\n print m2.id,\r\n print m2.m1.id", "If you need to prefix your models with the database name, you can try using the `schema` model metadata option. Example:\r\n\r\n```python\r\nclass MyModel(Model):\r\n data = TextField()\r\n class Meta:\r\n database = db1\r\n schema = 'db1'\r\n\r\nMyModel.select().sql()\r\n# SELECT \"t1\".\"id\", \"t1\".\"data\" FROM \"db1\".\"mymodel\" AS \"t1\"\r\n```", "thanks" ]

[]

[]

[ "Two reasons for that. One, sqlite has no boolean type. Two, in python true is literally the same as 1 and false is 0.", "Thanks for the comment. I was aware of that. That's why I thing it would be handy to have uniform type coercion. Original issue I ran into was that marshalling select query results into JSON with Sqlite3 and PG produces different output. I was expecting that mapping (isn't that what ORM is supposed to do) would shield me form limitations of the underlying DBs. Cheers!", "The values *are* coerced, though. It's just the storage type:\r\n\r\n```ipython\r\nIn [1]: from peewee import *\r\n\r\nIn [2]: db = SqliteDatabase(':memory:')\r\n\r\nIn [3]: class Test(Model):\r\n ...: value = BooleanField()\r\n ...: class Meta:\r\n ...: database = db\r\n ...: \r\n\r\nIn [4]: db.create_tables([Test])\r\n\r\nIn [5]: t = Test.create(value=True)\r\n\r\nIn [6]: f = Test.create(value=False)\r\n\r\nIn [7]: print Test.get(Test.id == t.id).value\r\nTrue\r\n\r\nIn [8]: print Test.get(Test.id == f.id).value\r\nFalse\r\n```" ]

[]

[]

[ "It seems that Peewee is quoting the tokenizer (both 2.x and 3.0a), it looks like:\r\n\r\n```sql\r\nCREATE VIRTUAL TABLE \"note\" USING FTS3 (\"content\", tokenize=\"icu en_AU\")\r\n```\r\n\r\nCan you do an experiment for me? Using Peewee (or just the plain old `sqlite3` module):\r\n\r\n```python\r\nfrom playhouse.sqlite_ext import *\r\ndb = SqliteExtDatabase(':memory:')\r\ndb.execute_sql('CREATE VIRTUAL TABLE thai_text USING fts3 (content, tokenize=icu th_TH);')\r\n```\r\n\r\nOr\r\n\r\n```python\r\nimport sqlite3\r\nconn = sqlite3.connect(':memory:')\r\nconn.execute('CREATE VIRTUAL TABLE thai_text USING fts3 (content, tokenize=icu th_TH);')\r\n```\r\n\r\nAnd let me know what happens?", "They work well, both of the methods above, by not quoting the tokenizer.", "Cool I didn't compile sqlite with icu so I wanted to double check that would work. I'll get a patch up today.", "Thanks!", "You mind trying out c88fc2ef08c4ed5e7214b7d30f0b20707db43995 and seeing if that resolves the issue?", "It works! Thanks so much!" ]

[]

[]

[ "Peewee has a helper called \"model_to_dict\" which can construct (recursively, if you desire) a dictionary containing model data, which can then be serialized as JSON.\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/playhouse.html#model_to_dict", "Thanks for answer, but I did try use backrefs parameter in model_to_dicts but don't worked for me.\r\n\r\n#My models:\r\n```\r\nclass TBEstados(BaseModel):\r\n ativo = IntegerField(null=True)\r\n nome = CharField()\r\n uf = CharField(null=True)\r\n\r\n class Meta:\r\n db_table = 'TBEstados'\r\n\r\nclass TBCidades(BaseModel):\r\n ativo = IntegerField(null=True)\r\n idestado = ForeignKeyField(db_column='idEstado', null=True, rel_model=TBEstados, to_field='id', backrefs=True)\r\n nome = CharField(null=True)\r\n\r\n class Meta:\r\n db_table = 'TBCidades\r\n```\r\n#select data \r\n\r\n`data = TBCidades.select().where(TBCidades.idestado == idEstado and TBCidades.ativo == True).dicts()`\r\n\r\n#Calling the model_to_dict function\r\n\r\n```\r\ndef toJSON(obj):\r\n obj = [model_to_dict(t, backrefs=True) for t in obj]\r\n return jsonify(obj)\r\n```\r\n\r\n#result JSON\r\n```\r\n[\r\n {\r\n \"ativo\": 1, \r\n \"id\": 1, \r\n \"idestado\": 1, \r\n \"nome\": \"Acrel\\u00e2ndia\"\r\n }\r\n]\r\n```", "You want `recurse=True` if the foreign key is on the model you're attempting to serialize.", "Thanks, but I did try use recurse=True and don't work.\r\n```\r\n\r\ndef toJSON(obj):\r\n obj = [model_to_dict(t, recurse=True) for t in obj]\r\n return jsonify(obj)\r\n```\r\n\r\nI ask me if haven't problem in my model." ]

[]

[]

[ "My guess is that the value of `Link` is from a previous call to `get_or_create`, which returns a 2-tuple of `<model instance>, <bool created?>`.\r\n\r\nCan you verify whether the value of `Link` is a tuple?", "Was that precisely!!! Thanks!!!", "If you forget that `get_or_create` returns a tuple and you try to save another model using the result as a field value, you can also get an error like the following: \r\n\r\n`TypeError: int() argument must be a string, a bytes-like object or a number, not 'tuple'`\r\n\r\n(Adding this comment as Google-bait so the next person who gets this error finds the answer sooner.)" ]

[]

[]

[ "CSV module is no longer included in Peewee as of 3.0.0.", "@coleifer is there a suggested replacement? This was a great simple way to dump stuff out.", "The dumping code is just a thin wrapper: https://github.com/coleifer/peewee/blob/stable/playhouse/csv_utils.py\r\n\r\nYou can easily backport it into your codebase." ]

[]

[]

[ "I understand your thinking, but unfortunately I'm worried about the implications of modifying this behavior in the 2.x branch. Perhaps I can introduce such a change in 3.x, though?", "Fixed in 3.0a. No exception is raised, `None` is simply returned as the field value." ]

[]

[]

[ "Very nice, thank you!" ]

[]

[]

[ "I cannot tell you which foreign key to join on, only you would know that. To specify the key, in the join method add an `on` argument:\r\n\r\n```python\r\nSomething.select().join(Other, on=Other.some_field)\r\n```" ]

[]

[]

[ "You need the 3.0a branches of wtf-peewee and flask-peewee, if your project depends on those libraries. Since I haven't merged 3.0a into master yet, you'll need to use the branches. When 3.0a is merged into peewee master, I'll merge the other libraries as well." ]

[]

[]

[ "Can't replicate:\r\n\r\n```python\r\nfrom peewee import *\r\nfrom playhouse.fields import ManyToManyField\r\n\r\ndatabase = SqliteDatabase(':memory:')\r\n\r\nclass BaseModel(Model):\r\n class Meta:\r\n database = database\r\n\r\nclass Hashtag(BaseModel):\r\n tag = TextField()\r\n\r\nclass Article(BaseModel):\r\n title = TextField()\r\n hashtags = ManyToManyField(Hashtag, related_name='articles')\r\n\r\nThroughModel = Article.hashtags.get_through_model()\r\n\r\ndatabase.create_tables([\r\n Hashtag,\r\n Article,\r\n ThroughModel])\r\n\r\narticle = Article(title='testing')\r\narticle.save()\r\n\r\nht1 = Hashtag.create(tag='ht1')\r\nht2 = Hashtag.create(tag='ht2')\r\narticle.hashtags.add([ht1, ht2])\r\narticle.save()\r\n\r\narticle_db = Article.get(Article.title == 'testing')\r\nfor ht in article_db.hashtags:\r\n print ht.tag\r\n```\r\n\r\nThe above code prints \"ht1\" and \"ht2\" as expected.", "I can't replicate it either on purpose :/\r\nI'm parsing a lot of data and suddenly it happens again and again..\r\nBut only on that element.\r\n\r\nI posted it here because the Error Message seams to be incorrect. Do you maybe have an idea how I can find out more about it or what I should do next to find the problem?", "Please see this line:\r\n\r\n```python\r\nhashtags = get_hashtag() # hashtags is an array of already saved hashtag-peewee-Model-Objects\r\n```\r\n\r\nI think your get_hashtag function have some problem, so the hashtags have duplicating-objects.\r\n\r\nI reproduced it by this script:\r\n\r\n```python\r\nhashtags = list(HashTag.select())\r\nhashtags = hashtags.extend(hashtags)\r\n```\r\n\r\nA easy way to test, you can try:\r\n\r\n```python\r\nhashtags = list(set(get_hashtag())) # hashtags is an array of already saved hashtag-peewee-Model-Objects\r\n```", "@yanghg-basefx thank you! Most likely that was the problem and now it seems to be working fine :+1: \r\n\r\nI didn't think of interpreting the error message that way!" ]

[]

[]

[ "Why are you closing the connection in the middle of iterating over a cursor? That makes no sense.", "This is only a reproducing. The problem is this issue often happened because some network fault so the connection was closed in the middle of iterating. \r\n\r\nIt is only happened between two different city's database connection in our company, and we can't make the connection much better.", "Gotcha -- you'll probably need to implement this on your end as some kind of \"re-connecting\" logic. But as far as integrating into peewee, that's above-and-beyond the scope of the project.", "OK, I see." ]

[]

[]

[ "What version of Peewee? What database driver?", "Closing due to inactivity.", "My peewee is 2.10.2 in python2, this case only appear when I use three tables. It disappeared when I leave two talbes", "Database driver is mysqldb.", "That's rather odd. Is there a reason you're using the call to `.alias()` all over the place instead of using the models themselves? What happens if you remove the calls to `alias()`?", "Ok,I will try it tomorrow. and I have an anther issue about BlobField , I use this field to store Binary img object successfully, but when I get this record use peewee why I get unicode object instead of binary object.\r\n", "```\r\nquery = SaoMstr.select(fn.MIN(SaoShip.ShipDate).alias('min_date'), SaoStyle.Style) \\\r\n .join(SaoShip, on=(SaoShip.OrderNo == SaoMstr.OrderNo)).join(SaoStyle, on=(SaoStyle.OrderNo == SaoMstr.OrderNo)) \\\r\n .where(SaoMstr.ExtTerm7 == '001', SaoMstr.Customer == '10011').group_by(SaoStyle.Style)\r\n\r\nIn [28]: type(query.get().min_date)\r\nOut[28]: unicode\r\n```\r\nWhen I delete ```SaoStyle.Style```:\r\n```query = SaoMstr.select(fn.MIN(SaoShip.ShipDate).alias('min_date')) \\\r\n .join(SaoShip, on=(SaoShip.OrderNo == SaoMstr.OrderNo)) \\\r\n .switch(SaoMstr).join(SaoStyle, on=(SaoStyle.OrderNo == SaoMstr.OrderNo).alias('st')) \\\r\n .where(SaoMstr.ExtTerm7 == '001', SaoMstr.Customer == '10011').group_by(SaoStyle.Style)\r\n\r\nIn [34]: type(query.get().min_date)\r\nOut[34]: datetime.datetime\r\n```\r\nAnd the following thing is very strange.\r\n```\r\nquery = SaoShip.select(fn.MIN(SaoShip.ShipDate).alias('min_date'), SaoStyle.Style).join(SaoStyle, on=(SaoStyle.OrderNo == SaoShip.OrderNo)).where(SaoShip.OrderNo == '0001000000001').group_by(SaoStyle.Style)\r\n\r\nIn [47]: type(query.get().min_date)\r\nOut[47]: unicode\r\n\r\n```\r\nWhat cause it ?\r\n\r\n\r\n\r\n", "Can you create a minimal example I can use to try and replicate this issue?" ]

[]

[]

[ "Try 8ba62478f7ce4fc3890fad0d1c42e851a382bdd4 ?", "Closing due to inactivity." ]

[]

[]

[ "Because I'm not interested in maintaining this functionality, I'd suggest packaging this as a standalone project.", "It seems like the schema resolver change would be necessary to build this as an independent package.", "Thanks for the comments. I can easily re-submit a patch containing only the schema resolution part in db_url. Indeed, this would make it much easier to create standalone extensions as suggested. Would such a pull-request be of enough interest to you?" ]