Datasets:

---

akumoth

/

peewee-issues

like 0

[]

[]

[ "Nope. That's a mysql-only thing.", "How to set comment in the model, can be described in the database can see the details", "It is not supported by sqlite or postgres.", "I am use mysql, which field can be described in the database can see the details", "Are you averse to adding dv-specific features?", "> Are you averse to adding dv-specific features?\r\n\r\nNot at all, but they have to be added in such a way that they are compatible. This patch would break hard if a user added help_text on sqlite or postgres. That's not compatible. There are *many* examples of compatibility in peewee -- on conflict handling, window function handling, data-types, etc, etc." ]

[]

[]

[ "You need to register the functions, which is not done automatically.\r\n\r\n```python\r\nfrom playhouse.sqlite_udf import median\r\n\r\ndb = SqliteDatabase(':memory:')\r\ndb.register_aggregate(median, 'median') # Will be available on all connections.\r\n```\r\n\r\nIf you want all of the functions/aggregates,\r\n\r\n```python\r\nfrom playhouse.sqlite_udf import register_all\r\n\r\ndb = SqliteDatabase(...)\r\nregister_all(db)\r\n\r\n# Or register just particular groupings, e.g.\r\nfrom playhouse.sqlite_udf import DATE, MATH\r\nfrom playhouse.sqlite_udf import register_groups\r\n\r\nregister_groups(db, DATE, MATH)\r\n```", "I have tried all three methods and keep getting the same traceback.\r\n\r\n```\r\nfrom peewee import *\r\nfrom database2 import Trial, Datapoint\r\nfrom datetime import datetime as dt\r\nfrom datetime import timedelta\r\nfrom playhouse.sqlite_udf import median\r\n\r\ndb = SqliteDatabase(':memory:')\r\ndb.register_aggregate(median, 'median')\r\n```\r\nI believe I had already included the register_all method in my previous code? \r\n```\r\nfrom peewee import *\r\nfrom database2 import Trial, Datapoint\r\nfrom datetime import datetime as dt\r\nfrom datetime import timedelta\r\nfrom playhouse.sqlite_udf import register_all\r\n\r\ndb = SqliteDatabase('sbir.db')\r\nregister_all(db)\r\n```\r\n\r\n```\r\nfrom peewee import *\r\nfrom database2 import Trial, Datapoint\r\nfrom datetime import datetime as dt\r\nfrom datetime import timedelta\r\nfrom playhouse.sqlite_udf import DATE, MATH\r\nfrom playhouse.sqlite_udf import register_groups\r\n\r\ndb = SqliteDatabase('sbir.db')\r\nregister_groups(db, DATE, MATH)\r\n```\r\n\r\nMy function has remained unchanged each time I ran the above changes. Do you have any other ideas?", "Works fine for me:\r\n\r\n```python\r\n\r\nIn [1]: from peewee import * \r\n\r\nIn [2]: from playhouse.sqlite_udf import * \r\n\r\nIn [3]: db = SqliteDatabase(':memory:') \r\n\r\nIn [4]: db.register_aggregate(median, 'median') \r\n\r\nIn [5]: class Reg(Model): \r\n ...: value = IntegerField() \r\n ...: class Meta: \r\n ...: database = db \r\n ...: \r\n\r\nIn [6]: Reg.create_table() \r\n\r\nIn [7]: Reg.insert_many([(i,) for i in [1, 5, 3, 6, 4, 2, 9]]).execute() \r\nOut[7]: 7\r\n\r\nIn [8]: Reg.select(fn.median(Reg.value)).scalar() \r\nOut[8]: 4\r\n```", "Looking at your code, are you sure that your models are bound to the same database that you are registering the aggregate on?\r\n\r\nAlso note this is covered by unit tests, and is not fundamentally broken." ]

[]

[]

[ "Bro are you high? Do you english?", "my phone apparently autocorrected a bunch...nice way to build a community....", "This might help: https://github.com/coleifer/peewee/blob/master/tests/fields.py#L1134-L1167", "For those running across this, I extrapolated from the link above. The fix is:\r\n```\r\nr = Select(None, [fn.ST_X(value).alias('x'), fn.ST_Y(value).alias('y')]).first(self.model._meta.database)\r\nreturn r['x'], r['y']\r\n```", "I would not recommend that, as it implies a query for every value. I'm not sure where or in what context you are executing this additional query.\r\n\r\nIt'd be better to, whenever selecting from this field, to do the conversion automatically. This is where the `db_value()` method comes into play, which is somewhat exemplified in the code I linked.", "I may have a misunderstanding of what `db_value()` is doing. I thought that it converted values for storing in the database? And `python_value()` converted database values to python values? I'm doing the above in `python_value()` as the representation of the geometry column as returned by SELECT is WKB. The appropriate SELECT to get the components of the field would be something like `SELECT ST_X(bbox),ST_Y(bbox) FROM tablename;` which returns 2 entries for a single column.", "What you're doing is super inefficient, is what I'm saying. If you run a query that returns 100 rows, you're sending off 100 *additional* queries. Nobody should do this, it's terrible advice and inefficient.\r\n\r\nAnother route is to modify your select so that you grab the values explicitly:\r\n\r\n```python\r\n\r\nquery = MyModel.select(\r\n MyModel, \r\n fn.ST_X(MyModel.bbox).alias('bbox_x'),\r\n fn.ST_Y(MyModel.bbox).alias('bbox_y'))\r\n```", "I understand that it's inefficient, I'm trying to figure out how to make the ORM do it in a single select and automatically populate the object. The context is something like:\r\n`\r\nclass Bar(Model):\r\n id = IntegerField(primary_key=True)\r\n\r\nclass Foo(Model):\r\n bbox = BoxField() # this is the custom field with the bbox accessor\r\n bar = ForeignKey(Bar, backref=\"foo\")\r\n\r\n# ...\r\ntmp = Bar.get(id=my_bar_id)\r\njson.dumps(model_to_dict(tmp))" ]

[]

[]

[ "Max digits corresponds to precision\r\nDecimal places corresponds to scale\r\n\r\nI'm not clear in your example whether you're using the \",\" as a thousands-separator or a decimal separator.\r\n\r\nIf unspecified, scale defaults to 5. So your example would be equivalent to:\r\n\r\n```\r\n\"price\" NUMERIC(15, 5) NOT NULL\r\n```\r\n\r\nI have absolutely no issues with this in a simple test-case:\r\n\r\n```python\r\n\r\nclass R(Model):\r\n val = DecimalField(max_digits=15)\r\n\r\nR.create(val=Decimal('100000.000')) # val='100000.000' also works fine.\r\nr = R.get()\r\nprint(r.val) # 100000.00000\r\n```\r\n\r\nSQL for the table:\r\n\r\n```sql\r\nCREATE TABLE IF NOT EXISTS \"r\" (\r\n \"id\" SERIAL NOT NULL PRIMARY KEY,\r\n \"val\" NUMERIC(15, 5) NOT NULL)\r\n```\r\n\r\nSomething is wrong with your schema or the code you've shared, but it appears working fine for me.\r\n\r\n> crypto startup\r\n\r\nnot even once" ]

[]

[]

[ "Yeah, this query is failing on MySQL but works OK for Sqlite or Postgres.\r\n\r\nFor sqlite, we have a rule to never put parentheses around the left- or right-hand side.\r\n\r\nFor postgres, we always do, since postgres handles it correctly.\r\n\r\nFor mysql, we have a rule to not put parentheses if the left- or right-hand side is itself a compound query. It appears this is overly-simplistic. I honestly don't understand how mysql decides when to handle parentheses vs choke/throw an error. I think I've hacked in a fix for now by checking if the compound query is inside an expression or function-call, and in that case to avoid using parens. If there's a better rule I can apply, I'd be eager to implement it.", "It appears that this particular sql parsing bug has existed in MySQL for over 12 years now:\r\n\r\nhttps://bugs.mysql.com/bug.php?id=25734\r\n\r\nIt appears to be fixed in 8.0, but I'm guessing you're either on 5.x or using MariaDB.\r\n\r\nMy suggestion is that although this is somewhat fixed, to try and re-work your query.", "MariaDB thought they fixed it for 10.4: https://jira.mariadb.org/browse/MDEV-11953\r\n\r\nBut they missed some scenarios, including using compound select queries inside an IN expression (e.g.). I've opened a ticket, so we'll see what happens: https://jira.mariadb.org/browse/MDEV-20606" ]

[]

[]

[ "So I took a quick look. You can't really rely on state or local memory being preserved between any two requests w/a lambda function, so I'm not sure if connection pooling makes sense in that environment (though you could try it and measure).\r\n\r\nI'd just wrap the `route()` function to add a decorator that opens and closes the db on each request.\r\n\r\n```python\r\n\r\napp = Chalice(...)\r\ndb = MySQLDatabase(...)\r\n# Or,\r\n# db = PooledMySQLDatabase(...)\r\n\r\ndef my_route(*args, **kwargs):\r\n def inner(fn):\r\n def deco(*fa, **fk):\r\n db.connect()\r\n try:\r\n return fn(*fa, **fk)\r\n finally:\r\n db.close()\r\n return app.route(*args, **kwargs)(deco)\r\n return inner\r\n\r\n@my_route('/foo/', ...)\r\ndef some_view(...):\r\n # db should be opened before this function is called\r\n # and will be closed afterwards\r\n```\r\n\r\nSomething like that -- I didn't test it, but hopefully you get the idea." ]

[]

[]

[ "I don't have sqlite3.h. I'll try to get that before trying again. ", "Yup. That was it. :man_facepalming: ", "The `setup.py` should print an error if you run `setup.py build_ext`...looks like maybe it got swallowed by `pip`? Not sure. At any rate, glad you got it sorted." ]

[]

[]

[ "seems that driver handle (escape) parameters itself instead of execute it as parameters in postgresql. Why doing that......", "Peewee follows the DB-API convention / interface for executing queries. The SQL query uses placeholders for values, which are then interpolated by the driver however that needs to happen. Postgres (psycopg2) implements escaping as part of the library. Sqlite, however, prepares/compiles the statement *with* the placeholders, then binds the values separately using the `sqlite3_bind_XXX` interfaces. So it's up to the driver to do the appropriate thing for the database.\r\n\r\nThis is done for:\r\n\r\n1. security. If you are binding your parameters, then you do not need to worry about sql injection attacks.\r\n2. performance. Sqlite, for example, can reuse a compiled statement with a different set of parameters, avoiding the need to compile a statement over-and-over when only the parameters have changed.", "In fact I want to use `asyncpg` to execute my peewee query asynchronous in my asyncio web server, which send query and parameters directly to postgresql server instead of escape it by python. So it only accepts query with `$1`,`$2` as placeholder. And simply custom `Context.param` won't work in this situation.\r\n\r\nDid that mean that there is no workaround now to get Postgresql compatible SQL string by `query.sql()`, only psycopg2 compatible? \r\n\r\nWhich means I have to handle SQL string after peewee generated it, I'm also considering security issues" ]

[]

[]

[ "Your database (sqlite) doesn't support IREGEXP. Just use a normal regexp with case-insensitive matches/captures." ]

[]

[]

[ "Originally this was expressed as 1, 10, 100, ... 1000000. I added the option to provide it as the exponent instead, but this broke the default of 1 (turning it into 10).\r\n\r\nFixed so that 0 and 1 both resolve to seconds resolution. To get 10th of a second, one needs to supply the resolution=10, but I don't think this is likely to be an issue. People tend to either use seconds, milliseconds or microseconds." ]

[]

[]

[ "Sqlite only supports a couple different data-types: https://sqlite.org/datatype3.html\r\n\r\nSqlite interprets DECIMAL fields as REAL, which is a double-precision / float64. So that is why you are losing precision. Sqlite is optimizing the storage by treating the value as a numeric quantity, but it can only implement the value as an int64 or a float64.\r\n\r\nIf you don't plan on doing any math on it ever, you could use a text column for the storage:\r\n\r\n```python\r\nclass SqliteDecimalField(DecimalField):\r\n field_type = 'TEXT'\r\n```\r\n\r\nThe above will store the value precisely, but it is stored as a string so as soon as you try to do math on it you'll run into the same types of issues as before.\r\n\r\nBasic database literacy is a good thing. I'd suggest reading the sqlite docs next time." ]

[]

[]

[ "Thanks, I haven't experimented too much with mysql-connector. There's a little helper class in `playhouse.mysql_ext`, but that's about it as most Peewee users stick with pymysql.\r\n\r\n> I changed mysql connection timeout to 10s, so it's quite easy to reproduce.\r\n\r\nYeesh, that seems extreme. What if you have a long-running calculation during a transaction, e.g. a batch process or something?\r\n\r\n> I made a dirty patch here to test self._state.conn.is_connected(). it's working, but I'm sure that's not the right cure.\r\n\r\nThis is definitely not the right place to fix it.\r\n\r\nThe `autoconnect`, `is_closed()`, etc., all refer to the *internal* connection state managed by peewee. e.g., autoconnect is enabled so that attempting to issue a query will establish a connection if one does not exist. Peewee leans on the driver to manage the actual underlying connection (the pool is slightly different, because that actually checks the \"liveness\" of connections).\r\n\r\nSo if you want automatic reconnect, I'd suggest using something like the `ReconnectMixin` from `playhouse.shortcuts`. It is designed to work with `pymysql` primarily, but could be extended for mysql-connector.\r\n\r\nThe reconnecting mixin will catch an error raised when obtaining a cursor and executing a query. It then can, depending on the error class and error message, reconnect and retry the query automatically. People use it for long-lived MySQL connections that may be closed by the server.\r\n\r\nUsage:\r\n\r\n```python\r\n\r\nclass ReconnectMySQLDatabase(ReconnectMixin, MySQLDatabase):\r\n pass\r\n\r\ndb = ReconnectMySQLDatabase(...)\r\n```", "I was able to replicate and resolve the issue by extending the ReconnectMixin list of errors to include the error raised by mysql-connector when an idle connection is killed by the server. You should now be able to use the `ReconnectMixin` from `master` and it will handle automatic re-connection." ]

[]

[]

[ "This is for tracking **issues**, not \"how-do-i\" questions. Please take it to stack overflow.\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/contributing.html#questions" ]

[]

[]

[ "That's an ancient version of mariadb, first of all. Second of all, it doesn't matter because that version is so old it doesn't support any of the features that the version-check is designed to flip." ]

[]

[]

[]

[]

[]

[]

[]

[]

[ "Thanks" ]

[]

[]

[ "The Method is still there:\r\n\r\n def first(self, database, n=1):\r\n\r\nhttps://github.com/coleifer/peewee/blob/b51b230a45e71464d90607ccfdd40ccff4d2d3f8/peewee.py#L2049", "thx for u response\r\nI see, I use it incorrect ,sry!\r\n\r\nI think it use likely the \"get()\" method. \r\nso i use it by mistake -> \r\n # Owner.first() # error use \r\n\r\nbut it should use correctly ->\r\n Owner.select().where(Owner.name=='Alice').first() # right use", "Beat me to it @oz123 thanks for helping out a newcomer." ]

[]

[]

[ "I can see both sides, but I do think that I will make the logic for adapting values more permissive. What changed is that an expression now looks a little bit harder to see if the right-hand-side can be converted using the conversion implied by the left-hand field. For a cast(), however, this should be more permissive.\r\n\r\nShould be working again: 92713817185aa7decf29234fe704ba2182c10196", "Actually, I changed my mind about how to fix this. Instead, I will look at the `_coerce` internal flag and use that to determine whether to apply the conversion.\r\n\r\n42e2b429c226590bac20770a8a10a4b4a9b0c897", "If it works, it works. 👍 Thank you for the fast fixing." ]

[]

[]

[ "Thank you, nice catch." ]

[]

[]

[ "get out of here with this crap, i don't have anything to do with whatever that is.", "Ah, I just assumed you were the maintainer for the conda-forge feedstock, but it looks like its someone else. Peewee has +100k installs through conda-forge https://github.com/conda-forge/peewee-feedstock", "Holy smokes! Never heard of it before." ]

[]

[]

[ "The base model *is not* created... you have to explicitly tell peewee which tables to create. It doesn't matter the inheritance chain -- each model class is just a single table.", "Thanks! \r\n\r\nI've been using peeweedbevolve for too long which creates all by default. Just found the answer here for my use case.\r\n\r\nhttps://github.com/keredson/peewee-db-evolve/issues/24#issuecomment-360875831" ]

[]

[]

[ "There are huge differences between sqlite/mysql/postgres for writing triggers. If you need a trigger, just create it after your call to `db.create_tables(...)`:\r\n\r\n```python\r\ndb.create_tables([MyModel, ...])\r\ndb.execute_sql('create trigger ...')\r\n```\r\n\r\nFor LISTEN/NOTIFY, again, I'm not sure how Peewee would improve on this much as it's pretty straightforward. Just use `db.execute_sql('listen channel_name')` to subscribe, and then for notify:\r\n\r\n```python\r\npayload = {'now': time.time(), 'data': 'something'}\r\ndb.execute_sql('notify channel_name, %s', (json.dumps(payload),))\r\n```\r\n\r\nThe psycopg2 docs contain an example of polling for updates, presumably you'd do this in a separate thread or use a coroutine library." ]

[]

[]

[ "> The suggested method of solving this in Django is trough the usage of a middleware but this assume that in that case peewee related db is the main one, and has resulted in errors like this one:\r\n\r\nThat has nothing to do with \"solving\" your connection timing out and being closed. That middleware is simply to ensure you are cleanly opening and releasing connections when Django views are accessed... as, presumably, you are accessing the database during the views.\r\n\r\nThe error you are receiving, \"object() takes no parameters\", is related to the API for middlewares changing in Django 2.x. https://docs.djangoproject.com/en/2.2/topics/http/middleware/\r\n\r\nYou'll need to implement this:\r\n\r\n```python\r\nclass SimpleMiddleware:\r\n def __init__(self, get_response):\r\n self.get_response = get_response\r\n # One-time configuration and initialization.\r\n\r\n def __call__(self, request):\r\n database.connect()\r\n\r\n response = self.get_response(request)\r\n\r\n if not database.is_closed(): database.close()\r\n return response\r\n```\r\n\r\nThis is a fairly special usage of Peewee and you should be knowledgeable about both Django and Peewee... By your issue and the description, it seems to me that this is not the case for you. Probably you should stick with Django." ]

[]

[]

[ "No" ]

[]

[]

[ "Here is a proposed implementation:\r\n\r\n```python\r\ndef __eq__(self, other: Any) -> bool:\r\n if other.__class__ != self.__class__:\r\n return False\r\n\r\n for field in self._meta.sorted_fields:\r\n if getattr(self, field.name) != getattr(other, field.name):\r\n return False\r\n\r\n return True\r\n```", "I can't imagine a situation in practice where such a comparison would be valuable. It suggests to me that there's a problem elsewhere in the implementation of your code. Models are not a representation of the state of the DB at all times. It's just simple active record. As such, comparing IDs seems reasonable but it's best to never need to compare model instances at all because of this." ]

[]

[]

[ "Part of this is how the PyMySQL driver is implemented.\r\n\r\nHowever, Peewee doesn't automatically reconnect to databases by default. Check out `playhouse.shortcuts.ReconnectMixin` if you want automatic database reconnects.\r\n\r\n```python\r\n\r\nclass ReconnectMySQLDatabase(ReconnectMixin, MySQLDatabase):\r\n pass\r\n\r\n# Your db should now automatically attempt to reconnect for certain types of errors.\r\ndb = ReconnectMySQLDatabase(...)\r\n```", "You may need to extend the list of `reconnect_errors` as an attribute on `ReconnectMixin`.", "How is that not default? Isn't peewee meant to be easy to use?\r\n\r\nThat's why I initially chose it, at least. People said it was easy but doesn't necessarily allow for more complex queries.\r\n\r\nThat aside, I can't find anything about a `ReconnectMixin` in the docs. Opening the playhouse docs and searching for `reconnect` with ctrl-f, it comes up empty. Searching for `reconnect` using the search bar in the top-left, it also comes up empty...", "I'm sorry you were so triggered by actually needing to think about software engineering. Blindly reconnecting is never going to be the default, as far as I'm concerned.\r\n\r\nYeah it was removed in 3.x and re-added recently (3.8 I think). It's there if you want it, but my opinion is its the DB drivers job to manage the connection (the socket/file/etc). If pymysql doesn't handle it, try opening the bug over there.", "Another consideration is what if the database connection drops out mid-transaction? If Peewee were to automatically re-connect, possibly the first half of the transaction would be lost." ]

[]

[]

[ "If you don't select anything from City, Peewee will mark the intervening model (Venue) as NULL. There was a similar issue reporting the opposite condition -- namely, not to use empty models. The current logic looks at the models as nodes in a graph. In your example, Venue is in the middle, connecting Event <- Venue <- City. Since you requested stuff on Event and City, Peewee sees that Venue is both a source (i.e., we joining *from* Venue) and a destination (we are joining *to* Venue). Because of this, Peewee will drop an empty model instance in place so that we can go from Event -> City even in the event no data is returned for Venue. Although that isn't the case here, that is the reason for that logic.\r\n\r\nThe way to avoid this would require looking through the graph each time a result row is constructed and pruning empty parts. I'm not too inclined to make that change, but it's probably the right one.\r\n\r\nIn the meantime, just add the appropriate conditionals to work around it.\r\n\r\n* if event.venue.is is None ?\r\n* fix `__str__` so that it's smarter about resolving foreign keys", "Going to mark this as a nice-to-have in the TODOs list.", "Thanks for the explanation. I suspected it might be something like that. Pruning it definitely sounds like the right solution.\r\n\r\nAlso, while I was implementing a workaround, I realized a more dangerous/relevant symptom of this issue. If in the `for events in q:` loop I wanted to condition something on if the event has a venue or not, I would do `if event.venue:` but this is True even for events without a venue (since they have an empty Venue object). As you recommended in your comment, `if event.venue.id:` works, but I could see this being a pesky bug to track down. Actually I think I _just_ realized that this is the cause of a weird bug I saw a while ago in my project...\r\n" ]

[]

[]

[ "I just answered my own question!!\r\n\r\n> .on_conflict(\r\n preserve=[Model.first_name, Model.last_name],\r\n update={Model.id: fn.last_insert_id(Model.id)}\r\n )" ]

[]

[]

[ "Here's some starter code\r\n\r\n```python\r\nfrom peewee import *\r\nfrom playhouse.sqlite_ext import *\r\n\r\ndb = CSqliteExtDatabase('/tmp/spellfix.db')\r\ndb.load_extension('/path/to/spellfix1')\r\n\r\nclass WordList(VirtualModel):\r\n # See http://www.sqlite.org/spellfix1.html\r\n word = VirtualField(TextField)\r\n rank = VirtualField(IntegerField)\r\n distance = VirtualField(IntegerField)\r\n langid = VirtualField(IntegerField)\r\n score = VirtualField(FloatField)\r\n matchlen = VirtualField(IntegerField)\r\n phonehash = VirtualField(TextField)\r\n top = VirtualField(IntegerField)\r\n scope = VirtualField(FloatField)\r\n soundslike = VirtualField(TextField)\r\n\r\n class Meta:\r\n database = db\r\n extension_module = 'spellfix1'\r\n primary_key = False\r\n\r\nWordList.create_table()\r\n\r\nwith db.atomic():\r\n with open('/path/to/dictionary') as fh:\r\n for word in fh:\r\n WordList.insert({'word': word.strip()}).execute()\r\n\r\nwords = (\r\n 'speling',\r\n 'heling',\r\n 'lhelping',\r\n)\r\nfor word in words:\r\n query = (WordList\r\n .select(WordList.word, WordList.score, WordList.distance,\r\n WordList.phonehash, WordList.matchlen)\r\n .where(NodeList((WordList.word, SQL('MATCH'), word)) &\r\n (WordList.top == 5))\r\n .dicts())\r\n print('WORD: %s' % word)\r\n for result in query:\r\n print(result)\r\n```", "Thank you Charles, much appreciated. \r\n\r\nYour blog has also been a great resource on closure.c, json1 and FTS5. Thanks for all you do!", "Since it was a bit cumbersome to get the spellfix extension along with the python packages I depend on, I made a pip-installable version of it: https://github.com/karlb/sqlite-spellfix. Maybe that is helpful for you, too.", "Excellent contribution @karlb thank you! Maybe we could make all the extensions pip installable like \"pip install sqlite-extensions[fts5,closures]\" using [extras_require](https://stackoverflow.com/a/60307740). I will take a look this weekend :)" ]

[]

[]

[ "Pushed a fix -- oid 701 appears to be double-precision, so it's up-to-date now. If your schema already exists, however, it doesn't matter because Python uses a double internally anyways. Lastly, if it's an issue, you are free to modify the fields yourself.\r\n\r\n> Alternatively, is there a way to access the Postgresql underlying type for a field without having to connect to the DB?\r\n\r\nI don't know what this means.", "Thanks, that works. My use for this case is that I have a tool that uses the introspection utils to generate PDF with the DB tables and columns, and it was assigning FLOAT to all the columns regardless of precision.\r\n\r\n> > Alternatively, is there a way to access the Postgresql underlying type for a field without having to connect to the DB?\r\n> \r\n> I don't know what this means.\r\n\r\nI meant if it's possible to get the PSQL type for a field (e.g., 'BIGINT', 'DOUBLE', 'REAL', 'VARCHAR', etc.)", "> I meant if it's possible to get the PSQL type for a field\r\n\r\nCheck the code in reflection, it has all the info you need. You can map the oid to the typname in the pg_type table." ]

[]

[]

[ "> Are there ways to declare 'qid' in peewee model as generated and never update it?\r\n\r\nYou're best off using `INSERT` or `UPDATE` directly in that case, so you can be more specific about which columns are being written to.\r\n\r\nPeewee typically handles server-side defaults just fine, as typically they are provided by the `DEFAULT` SQL clause, so NULLs are handled correctly. Apparently this particular example is a bit different.\r\n\r\nAnother option is to specify a list of fields to update when calling `save()`, e.g. `.save(only=[Project.utime])`.", "Hi Charles, thanks for the suggestion. An additional note on this - this issue exists on Mariadb 10.2.4+ and MySQL 5.7+ (when teams changed default for strict_mode). Rationale behind this can be found here - https://blog.sqlyog.com/beware-virtual-columns-may-render-backups-unusable/ at 4th comment.\r\n\r\nI showed an example - of course, in the example I can use INSERT/UPDATE directly, but you've invented Peewee to make life easier :-) and in real life I update lot of fields of an instance depending on lot of conditions and even not always know what exactly was updated, and, e.g. I just save the instance if \"dirty_fields\" is.\r\n\r\nOf course, it's the way to use smth like .save(except=[Project.qid]) (is it possible BTW?) but in fact it's the way to errors (if it was forgotten, for example) and, IMHO, it much more easier and safer is to define attribute 'computed' (well, 'readonly') and never include it in modify operations over DB (regardless of DB type). From the link above - \"This is a new feature, and with every new feature that affects DDL statements, the tools must evolve to deal with that. It has happened for triggers, stored routines, events, partitioning , and it must happen for virtual columns.\"\r\n\r\nThank you.", "It seems problematic and difficult to try and determine how to handle something like \"read-only\" fields. Calls to save() delegate to `.insert()` or `.update()`, so we would need to exclude read-only fields there. But should one prevent explicitly attempting to store data via calls directly to `.insert()` / `.update()` / `.insert_many()`? Validation would possibly need to be added in several places. Additionally, it's not clear how setting \"read-only\" would affect DDL ... do we prevent creating tables with read-only fields? Do we extend the field constructor to require specification of the expression/generator?\r\n\r\nAs long as you're not modifying a field's value, presumably it wouldn't be included in the list of dirty fields, so that should allow you to avoid this issue when using `.save()`.\r\n\r\nI'd suggest that you look at wrapping things in helper methods that do exactly what you want, and then just calling those. Trying to handle this correctly seems a bit fraught.", "Just look at this list of gotcha's a mile long. Fuck no:\r\n\r\nhttps://mariadb.com/kb/en/library/documentation/sql-statements-structure/sql-statements/data-definition/create/generated-columns/", ":-D Well, thank you!", "Hello, Charles, I fixed the problem by disabling strict_mode in DB, so it's not a problem for me anymore. But just one more comment to the statement \"Peewee typically handles server-side defaults just fine\". With new defaults it doesn't, actually.\r\n\r\nThere are two types of DB updates:\r\n- .update(), .insert() and others with explicit fields specification, where writer exactly know what he is doing and fully responsible for this. Issues with these operation can be easily tracked and fixed.\r\n- kinds of .save() with implicit fields specification, where Peewee takes responsibility of what exactly will be saved to DB.\r\n\r\nI think, it will be reasonable compromise to take care only about \"implicit\" calls like .save() where writer can't influence selection of fields to be saved. In this case field attribute like 'readonly' will allow to specify fields which is prohibited to update in DB.\r\n\r\nThank you.", "> I think, it will be reasonable compromise to take care only about \"implicit\" calls like .save() where writer can't influence selection of fields to be saved. In this case field attribute like 'readonly' will allow to specify fields which is prohibited to update in DB.\r\n\r\nI agree that this is probably the place to put such logic.\r\n\r\nMight be time to add it, because I recall someone asking for a readonly-type feature a while ago.", "For the issue of DDL, I think this will need to be handled by the user.", "I pushed a branch... I'm not in love with the way it's shaping out, but it provides a starting place.\r\n\r\nWill close this issue for now and put this on the back-burner to think about ways to integrate this stuff.", "Thanks, Charles! You're doing a great job. Thank you again." ]

[]

[]

[ "http://docs.peewee-orm.com/en/latest/peewee/contributing.html\r\n\r\nPost this on stackoverflow or ask in IRC. This forum is for issues." ]

[]

[]

[ "here is a minimum working version:\r\n```\r\nimport peewee\r\nfrom flask import current_app\r\nfrom playhouse.sqlite_ext import SqliteExtDatabase\r\n\r\nclass PeeweeDatabase:\r\n\r\n def init_app(self, app) -> None:\r\n app.before_request(self.perform_open)\r\n app.teardown_request(self.perform_close)\r\n\r\n def perform_open(self, *args, **kwargs) -> None:\r\n self.database.connect()\r\n\r\n def perform_close(self, *args, **kwargs) -> None:\r\n self.database.close()\r\n\r\n @property\r\n def flask_context(self) -> Any:\r\n return current_app\r\n\r\n def produce_database(self) -> peewee.Database:\r\n self.logger.debug(f\"produce_database\")\r\n datafile = current_app.config['DATABASE']\r\n return SqliteExtDatabase(datafile)\r\n\r\n @property\r\n def database(self) -> peewee.Database:\r\n context = self.flask_context\r\n if not hasattr(context, 'peewee_database'):\r\n context.peewee_database = self.produce_database()\r\n return context.peewee_database\r\n```\r\n", "I disagree with your assessment.\r\n\r\nYou create a `FlaskDB()` instance by either\r\n\r\n1. passing it a flask app instance\r\n2. calling `init_app()` later with an app instance\r\n\r\nThis binds the pre/post-request hooks for the given app.\r\n\r\nThere is a 1-to-1 between `FlaskDB` instances and `Flask` instances, in other words.", "I'm going to reopen this just to think about it a little more, but I'm not quite convinced that doing all kinds of magic with the app context is necessarily the right choice for this implementation.", "even more simplified example:\r\n\r\n```\r\nimport peewee\r\nfrom flask import Flask, current_app\r\nfrom playhouse.sqlite_ext import SqliteExtDatabase\r\n\r\nclass PeeweeDatawrap:\r\n\r\n def init_app(self, app:Flask) -> None:\r\n app.extensions['peewee_database'] = self.produce_database(app)\r\n app.before_request(self.perform_open)\r\n app.teardown_request(self.perform_close)\r\n\r\n def perform_open(self, *args, **kwargs) -> None:\r\n self.database.connect()\r\n\r\n def perform_close(self, *args, **kwargs) -> None:\r\n self.database.close()\r\n\r\n def produce_database(self, app:Flask) -> peewee.Database:\r\n datafile = app.config['DATABASE']\r\n return SqliteExtDatabase(datafile)\r\n\r\n @property\r\n def database(self) -> peewee.Database:\r\n return current_app.extensions['peewee_database']\r\n```\r\n", "with support for multiple database instances in the same flask app:\r\n```\r\nclass PeeweeDatawrap:\r\n\r\n def __init__(self, data_name:str='default'):\r\n self.data_name = f\"peewee_{data_name}\"\r\n\r\n def init_app(self, app:Flask,) -> None:\r\n assert not self.data_name in app.extensions, f\"duplicate entry: {self.data_name}\"\r\n app.extensions[self.data_name] = self.produce_database(app)\r\n\r\n # ... snip ... #\r\n\r\n @property\r\n def database(self) -> peewee.Database:\r\n return current_app.extensions[self.data_name]\r\n```", "Thanks for the links and the implementation suggestions. I'm going to refactor the `FlaskDB` to more closely follow the flask extension guidelines (support for multiple apps, support for multiple databases-per-app), as you've suggested.", "1. thank you.\r\n\r\n2. regarding the name: `FlaskDB`: \r\nbeing a for-flask extension, perhaps it should be flask-centric, \r\ni.e. make more sense from flask point of view, say: `PeeweeFlaskPlugin`\r\n", "There's an issue I realized once I started implementing some changes. Accessing the `database` relies on `current_app`. Which implies that accessing the `Model` property (which provides a base model class) will also require an app context.\r\n\r\nThis means that people will need to change their model code around and wrap everything in an app context. This would be quite disruptive for existing codebases.\r\n\r\nGoing to pass on changing the implementation for now, and if I do choose to make changes, will probably do so in a separate class that allows people to continue using `FlaskDB` without an app context.", "ok, I see.\r\n", "Just to get a bit more perspective I checked out the [flask-sqlachemy extension](https://flask-sqlalchemy.palletsprojects.com/en/2.x/) and the [code](https://github.com/pallets/flask-sqlalchemy/blob/master/flask_sqlalchemy/__init__.py) looks to have the same behavior as the peewee `FlaskDB` extension.", "1. well, we do not want to follow low standards, do we? :-)\r\n\r\n2. on another note, this pattern is also a major pain:\r\n```\r\nclass Model:\r\n class Meta:\r\n database: ...\r\n```\r\n\r\n3. perhaps switching peewee default database injection\r\nto flask-like `current_app` analogue would be less evil\r\n" ]

[]

[]

[ "You need to select it as well, then it will be available.\r\n\r\n```\r\nquery = (Fighter\r\n .select(Fighter, Timestamp)\r\n .join(Timestamp, on=(Fighter.id == Timestamp.id)))\r\nf = query.first()\r\n\r\nprint(f.left, f.right, f.timestamp.timestamp, f.timestamp.daytime)\r\n```", "http://docs.peewee-orm.com/en/latest/peewee/relationships.html#selecting-from-multiple-sources", "@coleifer Yes, but there are duplicate field names (id), how can I manage this? Can I select all fields except id field?\r\n\r\nEDIT: When I join two tables using SQL on id column it lefts only one id column, how can I do that using peewee?", "Peewee handles this correctly.\r\n\r\nIn my example,\r\n\r\n```\r\nf.id # the id of the fighter\r\nf.timestamp.id # the id of the timestamp\r\n```\r\n\r\nAlso presumably since you're joining on the id then you can infer one from the other.\r\n\r\nI'd not recommend joining an auto-generated id, by the way, as it would be too easy for them to become out-of sync. Better to use an explicit foreign-key.", "@coleifer Oh, let me show that:\r\n\r\n```\r\n games = (Fighter.select(Fighter, Timestamp).\r\n join(Timestamp, on=(Fighter.id == Timestamp.id))\r\n )\r\n print(games[0].timestamp.timestamp) # This prints fine\r\n for g in games.namedtuples(): # There is an error\r\n print(g)\r\n```\r\n\r\nTraceback:\r\n```\r\n File \"/usr/local/lib/python3.7/site-packages/peewee.py\", line 4127, in next\r\n self.cursor_wrapper.iterate()\r\n File \"/usr/local/lib/python3.7/site-packages/peewee.py\", line 4043, in iterate\r\n self.initialize() # Lazy initialization.\r\n File \"/usr/local/lib/python3.7/site-packages/peewee.py\", line 7065, in initialize\r\n self.tuple_class = collections.namedtuple('Row', attributes)\r\n File \"/usr/local/Cellar/python/3.7.3/Frameworks/Python.framework/Versions/3.7/lib/python3.7/collections/__init__.py\", line 373, in namedtuple\r\n raise ValueError(f'Encountered duplicate field name: {name!r}')\r\nValueError: Encountered duplicate field name: 'id'\r\n```\r\n\r\nIs it ok? If yes can you please explain it to me?\r\n\r\nUPD: I'm not so good in database architecture, id fields are inserting manually, they not auto-generated, there is one-to-one relationship, should I make id column in the second table as foreign key?\r\n\r\nUPD2: When I'm using `games.dicts()` instead of `games.namedtuples()` it works just as expected.", "The behavior is what it is, as Peewee does not handle nesting or relationship-traversal when using the dicts/namedtuples/tuples methods. You can explicitly alias Timestamp.id in the .select() call if you wish, but you need to then explicitly specify all the columns on Timestamp which you intend to select." ]

[]

[]

[ "This is why we have stuff like \"column_name\":\r\n\r\n```python\r\nclass MyModel(Model):\r\n insert_ = TextField(column_name='insert')\r\n```", "@coleifer \r\n\r\nI have made sure all my columns are explicitly named now by using your suggestion. I hope this GIF demonstrates well that even though the **insert** column has an explicit `column_name` set, the `self.insert` class method is still assuming the value of the field.\r\n\r\n\r\n", "Sorry, I think I get your point. I have to pay attention to the underscore you wrote down." ]

[]

[]

[ "I'm not in love with the way I've patched, this, but I have replicated the issue and believe it is fixed:\r\n\r\nef27f0209a7942e28ba976264ceaf85891277bb1\r\n\r\nI'd like to get a better handle on exactly when and where to apply such casts, but until I dive in deeper I suppose this will work.", "thanks for the quick response and the fix.", "Doesnt appear to be fixed.. but the error now is different:\r\n```\r\npeewee.ProgrammingError: syntax error at or near \"END\"\r\nLINE 1: ... SET \"db_tx_count\" = CASE \"metrics\".\"merchant_id\" END, \"db_a...\r\n```", "Perhaps you're passing an empty list? Not sure, however there is a test that is passing if you bother seeing the commit.", "@coleifer same thing happens with UUIDField.\r\nI inherited the UUIDField and applied the same fix, and seems to work well" ]

[]

[]

[]

[]

[]

[ "> But the problem with this is that db is undefined.\r\n\r\nBecause you're not returning anything...\r\n\r\nThis is not peewee-specific but a general question about Python module organization. When you have dependencies like this, the typical solution is to introduce a third module that composes the two (db and main)." ]

[]

[]

[ "Sqlite is indicating that you have a foreign-key constraint error. That is, one of the objects you are creating, is using an invalid foreign-key.\r\n\r\nPeewee attempts to convert the UUID instances in your models into their hex equivalent for storage, but it looks like one of your parameters is coming through with the dashes in place. Without seeing the \"training\" field it's hard for me to tell what's going on.", "Added a test-case and replicated what I guess to be the bug, which is also fixed in the above commit.", "thx\r\nits work" ]

[]

[]

[ "`pw.fn.ST_AsText(PadsLocations.latlng).alias('latlng')` does return the appropriate result, as a monkey-patch.", "Peewee relies on the driver to implement the db-api 2.0 spec. Part of this spec is that a cursor, after executing a query, contains a `description` property which tells us about the names of the columns being selected. This is determined by the database and then communicated to the driver. Presumably if you execute such a query in the mysql shell, the result column of such a function will not be \"latlng\" but something else.\r\n\r\nSo the correct thing to do, if you want to alias a function call to a given, is to explicitly specify the alias as you have done. Not a bug.\r\n\r\nConsider the case where you're grabbing a COUNT() or something. You'd have `fn.COUNT(MyModel.id)` or whatever. You wouldn't want that to default to being the value of \"MyModel.id\" ... so you explicitly alias it: `fn.COUNT(MyModel.id).alias('count')`.\r\n\r\n> as a monkey-patch\r\n\r\nlook up the definition of monkey-patch, you're using it incorrectly" ]

[]

[]

[ "What difference does it make what order the column is in the underlying storage? Absolutely none, truthfully." ]

[]

[]

[ "What's odd is that `time.time()` has microsecond precision on my machine. Granted, calling `time.time()` appears to take only ~80ns, but still there's a lot of stuff going on that would seem to make identical timestamps an impossibility. I'm fine with merging, but I can't wrap my head around how this could happen in the first place.", "Fixed and merged an equivalent (but not broken) patch." ]

[]

[]

[ "My guess is you're using an ancient version of sqlite. Try this and check the output:\r\n\r\n```python\r\n>>> import sqlite3\r\n>>> sqlite3.sqlite_version # My version is quite new.\r\n'3.29.0'\r\n```\r\n\r\nYou need to upgrade your sqlite for peewee to properly infer the column names.\r\n\r\nFor example, the following works fine on my machine:\r\n\r\n```python\r\ndb = SqliteDatabase(':memory:')\r\n\r\nclass Register(Model):\r\n key = TextField()\r\n value = IntegerField()\r\n class Meta:\r\n database = db\r\n\r\ndb.create_tables([Register])\r\n\r\nRegister.insert_many([('k%02d' % i, i) for i in range(100)]).execute()\r\n\r\ndb.execute_sql('create view \"small_reg\" as '\r\n 'select id, key, value from register '\r\n 'where value < 13')\r\n\r\nclass SmallReg(Register):\r\n class Meta:\r\n table_name = 'small_reg'\r\n\r\nquery = SmallReg.select()\r\nfor obj in query:\r\n print (obj.id, obj.key, obj.value)\r\n```", "Yes, I have SQLite 3.11.0.\r\n\r\nWhat minimal version is supported by peewee?\r\n\r\n> On 24 Jul 2019, at 05:02, Charles Leifer <[email protected]> wrote:\r\n> \r\n> Closed #1975.\r\n> \r\n> —\r\n> You are receiving this because you authored the thread.\r\n> Reply to this email directly, view it on GitHub, or mute the thread.\r\n", "That's actually not as old as I would have thought. I'm compiling an older sqlite and am going to check it out some more.", "So here's what's happening... Peewee makes use of database drivers implementing the db-api 2.0 spec (psycopg2, stdlib sqlite3, pymysql, etc). After executing a query using a cursor, the cursor exposes a `description` property that tells you the names of the selected columns.\r\n\r\nIn my above example, the `cursor.description` (as reported by the sqlite3 driver) is:\r\n\r\n```python\r\n>>> cursor.description \r\n(('t1', None, None, None, None, None, None), ('t1', None, None, None, None, None, None), ('t1', None, None, None, None, None, None))\r\n```\r\n\r\nThe column names reported by the driver use the `sqlite3_column_name()` API. Seems like this behavior changed... I'll do some more digging.", "I'm not sure why sqlite is behaving differently when using a view versus a regular table -- because it works as one would expect when querying a table. I suppose for now you can use a workaround of just explicitly aliasing the fields you select, or possibly try upgrading to a more recent sqlite?", "Thanks for your advises and fast response, I appreciate this. \r\n\r\nI'll probably use aliases as a workaround because it would be more bulletproof. For now it works, thank you!\r\n\r\n```python\r\n>>> store_items_view.select(store_items_view.color_id.alias('color_id')).get()\r\n<store_items_view: (None, 11, None, None, None, None, None)>\r\n>>> print(store_items_view.select(store_items_view.color_id.alias('color_id')))\r\nSELECT \"t1\".\"color_id\" AS \"color_id\" FROM \"store_items_view\" AS \"t1\"\r\n```\r\nIs there any short-cut to define aliases in a compact way?\r\n\r\nFYI, SQLA always defines aliases for every column. Probably, peewee need to do the same?", "I've patched this -- we use a more aggressive approach to slotting selected columns into the appropriate field slot. Tested it with sqlite 3.9 and verified it is working as expected.", "> SQLA always defines aliases for every column\r\n\r\nShould be no need to do this, honestly, except maybe for old versions of sqlite. I think I'll pass on that for now.", "So, I could expect fixed behavior in next release?\n\n> On 24 Jul 2019, at 17:35, Charles Leifer <[email protected]> wrote:\n> \n> I've patched this -- we use a more aggressive approach to slotting selected columns into the appropriate field slot. Tested it with sqlite 3.9 and verified it is working as expected.\n> \n> —\n> You are receiving this because you authored the thread.\n> Reply to this email directly, view it on GitHub, or mute the thread.\n", "yea", "Great! Thank you. \n\n> On 24 Jul 2019, at 17:57, Charles Leifer <[email protected]> wrote:\n> \n> yea\n> \n> —\n> You are receiving this because you authored the thread.\n> Reply to this email directly, view it on GitHub, or mute the thread.\n" ]

[]

[]

[ "You're welcome to override the default foreign-key index creation, by specifying `index=False` explicitly in the `ForeignKeyField` declaration/initialization.\r\n\r\nYou might double-check your information, however, to make sure that you actually *do* have an index on `user_id` in the referring table (`UserAccess`)." ]

[]

[]

[ "Thanks!" ]

[]

[]

[ "The underlying psycopg2 connection class is exposed as `db.connection()`, e.g.\r\n\r\n```python\r\ndb = PostgresqlDatabase('my_app')\r\nconn = db.connection() # returns current conn, opening one if necessary\r\n```\r\n\r\nThen use the psycopg2 apis to set the isolation level:\r\n\r\n```python\r\nfrom psycopg2 import extensions\r\nconn.set_isolation_level(extensions.ISOLATION_LEVEL_REPEATABLE_READ)\r\n```\r\n\r\nYou can put all this in a hook provided by peewee and executed automatically when a new connection is created.\r\n\r\n```python\r\n\r\nclass RCPostgresqlDatabase(PostgresqlDatabase):\r\n def _initialize_connection(self, conn):\r\n conn.set_isolation_level(...)\r\n```\r\n\r\nThis hook is called whenever a new connection is opened, so its probably what you're looking for.", "Added support for passing this into the PostgresqlDatabase `__init__()` method in master, will be available in the next release.", "@coleifer Thanks for the quick response and the code addition!\r\n\r\nDo you have any plan to add isolation level as a parameter to `db.atomic()` or `db.transaction()` in the future? Sometimes per-transaction config is needed rather than per-session....\r\n", "Not really, it seems from the psycopg2 docs that when you set the isolation level it is for the duration of the session, so there doesn't seem to be an API that is just for the lifetime of a transaction. Because of this, I'm inclined to leave it as an exercise to the reader to implement a context-manager or whatever you need.", "```python\r\n@contextmanager\r\ndef isolation(level):\r\n conn = db.connection()\r\n orig = conn.isolation_level\r\n conn.set_isolation_level(level)\r\n try:\r\n with db.atomic() as txn:\r\n yield txn\r\n finally:\r\n conn.set_isolation_level(orig)\r\n```\r\n\r\nSomething like this?", "OK. Thanks again.\r\n\r\nIn case someone else will encounter this thread - another possible option (which i didn't try) is to use raw [`SET TRANSACTION`](https://www.postgresql.org/docs/9.5/sql-set-transaction.html) statement which should be ran before any other query in the transaction." ]

[]

[]

[ "Instead of this, Peewee 3.x instead provides some really nice APIs for switching the database around at run-time.\r\n\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#Database.bind_ctx\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#Model.bind_ctx" ]

[]

[]

[ "Read the docs.\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/database.html#run-time-database-configuration" ]

[]

[]

[ "Well, the problem is either the descriptor protocol, or the implementation of `ModelAlias`.\r\n\r\nI find it simpler to look at this example, which I'm going to walk through just to get it all out in front of me to look at:\r\n\r\n```python\r\nclass Interval(Model):\r\n start = IntegerField()\r\n end = IntegerField()\r\n\r\n @hybrid_property\r\n def length(self):\r\n return self.end - self.start\r\n```\r\n\r\nThe `length` attribute implements the descriptor protocol, so it has `__get__()` which is called when the attribute is accessed as either a class attribute or instance attribute. `hybrid_property` is the simple case where we can pass either the model class or a model instance into the `length()` function as `self`.\r\n\r\nSo we either end up with:\r\n\r\n```python\r\nInterval.length -> length(self=Interval) -> Interval.end - Interval.start\r\n\r\nobj = Interval()\r\nobj.length -> length(self=obj) -> obj.end - obj.start\r\n```\r\n\r\nModel aliases are not subclasses of the model being aliased (though perhaps they ought to be) -- rather they are implemented as a simple proxy object. So when you look up the length attribute on a model alias, you get:\r\n\r\n```python\r\nIA = Interval.alias()\r\nIA.length -> ModelAlias(model=Interval) -> self.model.length -> length(self=Interval)\r\n```\r\n\r\nI'm not sure how to fix this one off the top of my head.", "So it's possible to look at the model's `__dict__` while resolving the attribute on the alias, and then (if it's a hybrid property) explicitly passing `self` instead of `self.model` into the appropriate method on the `hybrid_property` instance....but...yuck.", "Oh, I think I recall one of the reasons why we aren't doing model aliases as dynamically-created subclasses -- because of side-effects that occur when you declare foreign-keys in a derived class. So you subclass a model that has a foreign-key, it adds some stuff to the related model's metadata.\r\n\r\n```python\r\nclass User(Model):\r\n username = TextField()\r\n\r\nclass Tweet(Model):\r\n user = ForeignKeyField(User, backref='tweets')\r\n content = TextField()\r\n\r\nclass SubTweet(Tweet):\r\n pass\r\n\r\n# Now User._meta.backrefs contains a reference to \"SubTweet.user\", e.g.\r\n```", "That said, getting rid of ModelAlias would remove some rather yucky conditionals and things... Probably be a really big win if I can pin down these side-effects and handle them nicely. Just thinking out loud.", "I'm gonna leave this with the patch from 9e4f1fa at the moment." ]

[]

[]

[ "Peewee issues parameterized queries. All the db drivers peewee works with out-of-the-box support this, so the `.sql()` method returns the query and the params, which is exactly what is sent to the db.\r\n\r\nIf you want to try, you can use `peewee.query_to_string(q)` which will interpolate the parameters, but this is obviously vulnerable to sql injection and is only provided for debugging." ]

[]

[]

[ "`model_to_dict` is a convenience helper, but people definitely tend to treat it as the be-all/end-all of putting their model data in a dict.\r\n\r\nYou can try excluding the `study` field and specifying `extra_attrs=['study_id']` which will use the built-in foreign-key object ID accessor. That may work.", "Thanks, I'll give that a go!" ]

[]

[]

[ "I don't really understand, nor am I familiar w/SQLAlchemy, so the code example makes no sense to me.\r\n\r\nIn short, if you want a foreign-key, use the foreign key field.\r\n\r\nIf not, use an `IntegerField` and add a property to your model class.\r\n\r\n```python\r\nclass Tweet(Model):\r\n user_id = IntegerField()\r\n\r\n @property\r\n def user(self):\r\n return User.get(User.id == self.user_id)\r\n```\r\n\r\nBut I have no idea why you would want to do this.", "Yes, you can.\r\n\r\n`myfield = peewee.ForeignKeyField(OtherModel, lazy_load=True, _deferred=True)`\r\n\r\nI can confirm `_deferred` does not generate shit like\r\n\r\n```\r\n FOREIGN KEY (`myfield_id`) REFERENCES `othermodel` (`id`)\r\n```" ]

[]

[]

[ "```python\r\nclass SomeField(Field):\r\n field_type = 'inet'\r\n```\r\n\r\nIf you require conversion from python data-types to db-friendly data-types, you would implement `python_value()` and `db_value()` as needed.\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/models.html#custom-fields" ]

[]

[]

[ "Going to pass on this and require the condition when multiple FKs are present." ]

[]

[]

[ "My sense is to keep this explicit when multiple FKs are present, regardless of what the previous (2.x?) behavior may have been.", "that's a bummer. I have heaps of queries that used to work with 2.x but now are broken (all tables have these created_by and modified_by)", "Well let me reconsider.", "Merged equivalent patch thanks." ]

[]

[]

[ "In a many-to-many things are complicated. Depending on how you join, you're going to get duplicated data on one side or the other. Remember that the output of any query is always going to be a flat table-like data-structure. There is no nesting. So no rolling up of multiple Books for a single User. You'll get one User and one Book per User `times` Book.\r\n\r\nYou can still access this, you'd probably do something like\r\n\r\n```python\r\nfor user in query:\r\n related_book = user.book_relationship.book # Something like this, depends on your field names.\r\n```\r\n\r\nYour best bet is to do something like this:\r\n\r\n```python\r\nuser = User.get(User.username == 'charlie')\r\nliked_books = Book.select().join(BookRelationship, on=BookRelationship.from_user).where(BookRelationship.to_user=user)\r\n```" ]

[]

[]

[]

[]

[]

[]

[]

[]

[ "I also have a similar issue when doing a `bulk_update`. Though I do have `pmid = pw.IntegerField(unique=True)` in my model.\r\n\r\n```python\r\n with self.dbase.atomic():\r\n for idx in range(0, num_papers_update, n_batch):\r\n db.PaperDB.bulk_update(self.update_l[idx:idx+n_batch],fields=[db.PaperDB.pmid,\r\n db.PaperDB.title,\r\n db.PaperDB.abstract,\r\n db.PaperDB.journal,\r\n db.PaperDB.authors,\r\n db.PaperDB.pubdate,\r\n db.PaperDB.mesh_terms,\r\n db.PaperDB.publication_types,\r\n db.PaperDB.chemical_list,\r\n db.PaperDB.keywords,\r\n db.PaperDB.doi,\r\n db.PaperDB.delete,\r\n db.PaperDB.affiliations,\r\n db.PaperDB.pmc,\r\n db.PaperDB.other_id,\r\n db.PaperDB.medline_ta,\r\n db.PaperDB.nlm_unique_id,\r\n db.PaperDB.issn_linking,\r\n db.PaperDB.country,\r\n db.PaperDB.pubyear,\r\n db.PaperDB.pubmonth,\r\n db.PaperDB.pubday])\r\n```\r\n```bash\r\n~/anaconda3/lib/python3.8/site-packages/peewee.py in bulk_update(cls, model_list, fields, batch_size)\r\n 6350 \r\n 6351 for batch in batches:\r\n-> 6352 id_list = [model._pk for model in batch]\r\n 6353 update = {}\r\n 6354 for field, attr in zip(fields, attrs):\r\n\r\n~/anaconda3/lib/python3.8/site-packages/peewee.py in <listcomp>(.0)\r\n 6350 \r\n 6351 for batch in batches:\r\n-> 6352 id_list = [model._pk for model in batch]\r\n 6353 update = {}\r\n 6354 for field, attr in zip(fields, attrs):\r\n\r\nAttributeError: 'dict' object has no attribute '_pk'\r\n\r\n```\r\n\r\nAdditionally is there a way to not need to define all the fields repeatedly here and just update all fields with the incoming fields? Or could bulk_update just update the relevant ones in the list item that are being fed in?", "http://docs.peewee-orm.com/en/latest/peewee/api.html#Model.bulk_update - you have to pass list of model instances to `bulk_update()`." ]