Datasets:

---

akumoth

/

peewee-issues

like 0

[]

[]

[ "Oh, interesting, I hadn't thought of nested execution contexts but I can see how that might happen in a large enough codebase.\r\n\r\nSo when you use nested execution context, you expect a transaction to cover the outermost block, right?", "Basically my thought was that inner `__exit__` commits it's transaction, but shouldn't try to close the connection. Don't know if it's possible without some sort of `execution_context_depth`.", "Fixed. Behaves like nested `atomic()` blocks, with the additional behavior that the outermost block will close the connection upon exit.", "Thanks much, that was quick!" ]

[]

[]

[ "False.\r\n\r\n```python\r\nIn [1]: from playhouse.reflection import generate_models\r\n\r\nIn [2]: from peewee import PostgresqlDatabase\r\n\r\nIn [3]: db = PostgresqlDatabase('my_app')\r\n\r\nIn [4]: models = generate_models(db) # models is now a dict of table name -> model class.\r\n```", "\r\n", "\r\n@coleifer , are there known compatibility issues with python3?", "No, sorry I didn't see you had an older version. The generate_models helper was added here:\r\n\r\nhttps://github.com/coleifer/peewee/commit/23dad105456bf4034d3ee21c6d29e56a7e2b9c7a" ]

[]

[]

[ "You are clearly using models generated using the `pwiz` tool. If pwiz cannot determine the right field type to use for a column, it uses a placeholder \"UnknownField\". You will need to edit your model definitions and replace the UnknownField with an appropriate field type (e.g. TextField, IntegerField, whatever) if you wish to be able to use it in queries.", "> You are clearly using models generated using the `pwiz` tool. If pwiz cannot determine the right field type to use for a column, it uses a placeholder \"UnknownField\". You will need to edit your model definitions and replace the UnknownField with an appropriate field type (e.g. TextField, IntegerField, whatever) if you wish to be able to use it in queries.\r\n\r\nThanks.\r\nDue to pwiz generate mysql bit field to UnKnownField. " ]

[]

[]

[ "Well, for one, that's quite an old version of Peewee.\r\n\r\nThe other issue is the use of \"#\" in the password. Peewee's db_url module uses the stdlib url parsing library, which seems to choke on the \"#\" in the password for whatever reason.\r\n\r\nI'd suggest opening a bug on the Python bug-tracker, if one does not exist.\r\n\r\nFor Peewee, you'll need to figure out a workaround or just avoid the db_url module in this case." ]

[]

[]

[ "Well, part of the issue is that you are creating foreign-key constraints to a composite primary key -- but the fk constraints are to the individual columns that comprise the primary key rather than the (model_number, color) tuple. So, your schema is actually pretty broken.\r\n\r\nYou would instead do something like this (which is described in [the documentation](http://docs.peewee-orm.com/en/latest/peewee/models.html#table-constraints)):\r\n\r\n```python\r\nclass Sku(Model):\r\n upc_code = peewee.CharField(primary_key=True)\r\n model_number = peewee.CharField()\r\n color = peewee.CharField()\r\n\r\n class Meta:\r\n constraints = [SQL('FOREIGN KEY(model_number, color) '\r\n 'REFERENCES product(model_number, color)')]\r\n database = db\r\n\r\n @property\r\n def product(self):\r\n return Product.get(\r\n (Product.model_number == self.model_number) &\r\n (Product.color == self.color))\r\n\r\n @product.setter\r\n def product(self, obj):\r\n self.model_number = obj.model_number\r\n self.color = obj.color\r\n```\r\n\r\nI've fixed the underlying issue, however, so your example is running correctly now.", "Thank you for fixing and for the advice on composite foreign key constraints, much appreciated.", "Whoops, I still had left the `Sku.model_number` and `Sku.color` as foreign key fields -- they should actually be `CharField`. Fixed the code snippet above so that it now reads:\r\n\r\n```python\r\nclass Sku(Model):\r\n upc_code = peewee.CharField(primary_key=True)\r\n model_number = peewee.CharField()\r\n color = peewee.CharField()\r\n\r\n class Meta:\r\n constraints = [SQL('FOREIGN KEY(model_number, color) '\r\n 'REFERENCES product(model_number, color)')]\r\n database = db\r\n```" ]

[]

[]

[ "Fixed. Pushing 3.9.5", "Thanks for the quick response." ]

[]

[]

[ "Thanks for reporting.", "MySQL doesn't appear to support that syntax, as far as I can tell. [Docs](https://dev.mysql.com/doc/refman/5.7/en/control-flow-functions.html#operator_case) for 5.7. One would need to write:\r\n```\r\nCASE\r\n WHEN site_id = X1 AND id = Y1 THEN ...\r\n WHEN site_id = X2 AND id = Y2 THEN ...\r\nEND\r\n```\r\n\r\nSimilarly, it doesn't appear to support tuple comparison in the WHERE clause.\r\n\r\nTesting with a relatively recent version of Sqlite, I was able to get it working with minimal changes. Postgres looked to be roughly the same, but required explicit CASTs in places I wasn't expecting.\r\n\r\nIn short, I don't feel there's enough to be gained here by trying to support all these various edge-cases, so I've caused bulk_update() to raise an error if the model uses a composite pk.", "Actually MySQL supports tuple comparison in the WHERE clause and the CASE clause you gave is right.\r\n\r\nI just confirmed it in MySQL 5.7. For example:\r\n\r\n```sql\r\nUPDATE `article` \r\nSET `title` = CASE \r\n\tWHEN site_id = 1 and id = 'a1' THEN 'a11111'\r\n\tWHEN site_id = 1 and id = 'a2' THEN 'a22222'\r\nEND \r\nWHERE (`site_id`, `id`) IN ((1, 'a1'), (1, 'a2'))\r\n```\r\n\r\nThis shall do the bulk_update work when using composite keys. By the way, composite keys are widely using in our team, since we're using a distributed MySQL database. In this case, `site_id` is used to locate the node and `id` is the unique identifier. \r\n\r\nSo do you think it's possible to support the syntax above?", "Possibly, but as I was saying, Sqlite and Postgres both have their own quirks as well. Not to mention potential incompatibility in MySQL prior to 5.7?" ]

[]

[]

[ "Well, the easiest way of course is just to use the `SQL()` helper to insert the sql literal directly (SQL() also supports parameterization):\r\n\r\n```python\r\n\r\nquery = MyModel.select(SQL('TOP 10'))\r\n\r\nquery = MyModel.select(SQL('TOP %s', (10,)))\r\n```\r\n\r\nBut more generally to be able to translate a call to `.limit(10)` method, you will probably have a hard time. Unfortunately, at this time, Peewee doesn't provide the level of flexibility in overriding the essentials of the query-building APIs. That's because Model.select delegates to a ModelSelect which extends Select, etc., and it's not straightforward how one would generalize a change to the query building. You could subclass Model and override the select classmethod to provide your own implementation of ModelSelect, of course.", "Thank you. I will play around with those suggestions 👍 " ]

[]

[]

[ "With method chaining, we like to act that the queries at each step are immutable, so a copy is returned whenever the query is changed. You just need to reassign:\r\n\r\n```python\r\nentries = entries.limit(limit)\r\n```\r\n\r\nBut your code is gross on just about every possible level for such a short piece of code.\r\n\r\n* Default of -1 is gross. It could just as easily be zero, if you take a look at the way you've written your conditional...\r\n* But you don't need to use -1 or 0, just use None\r\n* In fact, you don't even need the condition, because specifying .limit(None) is the same as not specifying any limit\r\n* Why coerce to a list before returning? That forces the query to be evaluated and effectively limits the reuse of that function for any subsequent query-building. Just return the query object -- that way you can apply additional filters/etc if you need to later.\r\n\r\n```python\r\ndef get_entries(limit=None):\r\n return Entry.select().limit(limit)\r\n```", "Hey, thanks for your reply. \r\n\r\n> But your code is gross on just about every possible level for such a short piece of code.\r\n\r\nI would use the excuse, that it was pretty late as I was writing this but I guess I'm just dumb (: \r\n\r\n> But you don't need to use -1 or 0, just use None\r\n\r\nI wasn't aware of this. Even if in the documentation, this value default to `None`, I didn't find a hint that if `None` if passed, the query is evaluated without a `Limit`. \r\n\r\n> Why coerce to a list before returning? That forces the query to be evaluated and effectively limits the reuse of that function for any subsequent query-building. Just return the query object -- that way you can apply additional filters/etc if you need to later.\r\n\r\nYou are having a point here I guess. My thought on this was to wrap all peewee specific calls into a dedicated module and returning pure python objects.\r\n\r\nBut since the object which is returned from `select()` is iterate-able, there is no need to build a python list from the result." ]

[]

[]

[ "Historically Peewee hasn't really offered much support for fields whose defaults are generated on the server. Postgresql has a nice RETURNING clause support which we can use to obtain the server-generated values without incurring an additional query, but no such thing exists for MySQL or Sqlite at the time of writing. MySQL and Sqlite *do*, however, have APIs for obtaining the primary key of the last-inserted row when that row uses an auto-incrementing integer primary key.\r\n\r\nSo the way it worked is -- you use an auto-incrementing integer primary key (the default when declaring a peewee model), and your IDs will be populated correctly after calling save() or create().\r\n\r\nIf you are using a non-auto-incrementing ID, and the value is generated from the Python application, that's no problem. Because you are generating the ID, everything works.\r\n\r\nHowever -- if you have a non-auto-incrementing ID *and* it is generated by the database server -- historically Peewee has not populated the ID after the insert.\r\n\r\nI've made a change in 1be9f329523297cf27855c9276de3904aa968189 that will more aggressively set the primary-key on the model after insert, in the event that it is available (via RETURNING or whatever). Since Peewee already utilizes the RETURNING clause when inserting models into postgres dbs, Peewee should now be working for your use case.\r\n\r\n```python\r\nemail = EmailAddresses.create(\r\n account_uuid= str(account_uuid),\r\n email= \"[email protected]\",\r\n primary=True,\r\n verified=True)\r\nprint(email.uuid) # will print the uuid now.\r\n```\r\n\r\nFor the more general case of populating arbitrary model fields from the database after save, Peewee currently does not do this automatically.\r\n\r\nIf you had multiple fields that were being populated by the DB on insert, you could just use the insert + returning APIs to achieve an equivalent effect for arbitrary columns:\r\n\r\n```python\r\niq = EmailAddress.insert(\r\n account_uuid=str(account_uuid),\r\n primary=True,\r\n verified=True).returning(EmailAddress)\r\n# The insert+returning query returns an EmailAddress instance fully-populated:\r\nemail = list(iq.objects())[0]\r\n```" ]

[]

[]

[ "For the first one, depends on the data-type of the timestamp column, the database driver and the db you're using. You can try using `.where(MyModel.timestamp > float('-inf'))` but it may or may not work. A much saner way would be to use `datetime.datetime.min` instead of \"-infinity\".\r\n\r\nFor insert / on conflict, there are [extensive docs](http://docs.peewee-orm.com/en/latest/peewee/querying.html#upsert) along with [API documentation](http://docs.peewee-orm.com/en/latest/peewee/api.html#Insert.on_conflict).\r\n\r\nTo reference the default, you can use `SQL('DEFAULT')`, e.g.:\r\n\r\n```python\r\n\r\nTable.insert(id=1, col1='foo').on_conflict(\r\n conflict_target=[Table.id],\r\n update={Table.col1: SQL('DEFAULT')})\r\n```\r\n\r\nAlso, please read the documentation. I've clearly requested that, if you have questions, you do not open github issues: http://docs.peewee-orm.com/en/latest/peewee/contributing.html#questions -- stackoverflow, the mailing-list, and the irc channel are all good places to ask questions.", "note: i believe peewee.AsIs('-infinity') and peewee.AsIs('DEFAULT') is solving me issue. but I find no reference to the method in the documentation.", "That's fine, or `SQL('-infinity')` / `SQL('DEFAULT')` would probably be the more usual way.", "I had issues w/ SQL inproperly quoting '-infinity'. that was the first thing I tried. ./shrug.", "```\r\nModel.select().where(Model.timestamp > peewee.SQL('-infinity')).execute()\r\n```\r\n\r\nfails with `peewee.ProgrammingError: column \"infinity\" does not exist` because it doesn't quote.\r\nand if you try to force the quotes it starts escaping them (which is fine btw)\r\n\r\n```\r\nModel.select().where(Model.created_at > peewee.AsIs('-infinity')).execute()\r\n```\r\nsucceeds because it quotes.\r\n\r\nthe fact AsIs isn't anywhere in the documentation lead to the issue being filed.", "> the fact AsIs isn't anywhere in the documentation lead to the issue being filed.\r\n\r\nAnd yet your issue makes no mention of `AsIs` until we get down to the comments.\r\n\r\nDid you try `Value('-infinity')` ?" ]

[]

[]

[ "Fixed.", "Thank you so much!" ]

[]

[]

[ "You probably need to run that in a transaction and rollback the transaction in the event an integrity error occurs:\r\n\r\n```python\r\n try:\r\n with database.atomic():\r\n if grouping_key_id:\r\n grouping_key_obj = hook_log.query_grouping_key_by_id(grouping_key_id)\r\n grouping_key_obj.service_name = service_name\r\n grouping_key_obj.grouping_key = grouping_key\r\n grouping_key_obj.save()\r\n else:\r\n hook_log.create_grouping_key(service_name, grouping_key)\r\n except IntegrityError:\r\n # do something\r\n pass\r\n```", "oh!! I find when I create the Database object, I can set autorollback flag to True, it is useful.", "Yes, you can definitely use `autorollback`. This feature was requested by some users and although I do *not* like it, enough people have expressed interest that it is implemented.\r\n\r\nI would never use it in my own code. Better to use explicit transactions around data-modifying code (`with db.atomic(): ...`)." ]

[]

[]

[ "Sure - `ForeignKeyField` has an `accessor_class`, which is `ForeignKeyAccessor`. This is a descriptor and it implements a `get_rel_instance()` method, which is what does the actual query for the related obj.\r\n\r\nI haven't tested this, but probably something like this ought to work:\r\n\r\n```python\r\nclass NoQueryForeignKeyAccessor(ForeignKeyAccessor):\r\n def get_rel_instance(self, instance):\r\n value = instance.__data__.get(self.name)\r\n if value is not None:\r\n if self.name in instance.__rel__:\r\n return instance.__rel__[self.name]\r\n else:\r\n # Ordinarily this would be a query...Instead let's just return the FK col value?\r\n return value\r\n elif not self.field.null:\r\n raise self.rel_model.DoesNotExist\r\n\r\nclass NoQueryForeignKeyField(ForeignKeyField):\r\n accessor_class = NoQueryForeignKeyAccessor\r\n```", "Makes sense. Thanks!", "I've got an implementation in a branch you can check out: https://github.com/coleifer/peewee/tree/feature/disable-fk-lazy-load\r\n\r\nIt adds an option to `ForeignKeyField`, `lazy_load`, which defaults to True but can be set to False to prevent lazy loading the related model instance.", "Perfect! I briefly played with it and that works well.", "Merged into master, will be included in the next release." ]

[]

[]

[ "Peewee uses a special hook, `Database._initialize_connection(self, conn)`, which you can subclass and override to implement special logic when a new connection is opened.\r\n\r\nUntested, but presumably something like this:\r\n\r\n```python\r\nclass PgBouncerPostgresqlDatabase(PostgresqlDatabase):\r\n def _initialize_connection(self, conn):\r\n curs = conn.cursor()\r\n curs.execute('set statement_timeout=\\'1ms\\'')\r\n```\r\n\r\nI'm not sure what the ramifications of transaction-mode would be, and how that would interact with Peewee's own connection management or whatever. But yeah, I guess you could override the `begin()` method as well:\r\n\r\n```python\r\nclass PgBouncerPostgresqlDatabase(PostgresqlDatabase):\r\n def _initialize_connection(self, conn):\r\n curs = conn.cursor()\r\n curs.execute('set statement_timeout=\\'1ms\\'')\r\n\r\n def begin(self):\r\n self.execute_sql('SET ...')\r\n```", "I'll give those a try, thanks!", "Tried the suggestions above.\r\n\r\n```python\r\n def begin(self):\r\n self.execute_sql('SET ...')\r\n```\r\n\r\nThis seems to work only when transaction is explicitly defined (e.g. `with db.atomic()`). It doesn't trigger with `autocommit=True`.\r\n\r\nAlso, it only worked for me if I _didn't_ use `LOCAL` and only did `SET statement_timeout=...`.\r\n\r\nPostgres docs say:\r\n\r\n> The effects of SET LOCAL last only till the end of the current transaction, whether committed or not.--\r\n\r\nIn the logs, I cannot see any `BEGIN`, `COMMIT` or `SAVEPOINT` messages so I'm not sure what `db.atomic()` actually triggers. I guess `SET LOCAL` gets run in wrong context and thus doesn't go into effect. I looked into code but it would take time to get into it...\r\n\r\nOn the other hand:\r\n\r\n```python\r\n def _initialize_connection(self, conn):\r\n curs = conn.cursor()\r\n curs.execute('set statement_timeout=\\'1ms\\'')\r\n```\r\n\r\nThis works fine. So, I think I'm just going to use session-wide parameters instead of in-transaction (`LOCAL`).", "> This seems to work only when transaction is explicitly defined (e.g. with db.atomic()). It doesn't trigger with autocommit=True.\r\n\r\nYes, that's correct.\r\n\r\n> In the logs, I cannot see any BEGIN, COMMIT or SAVEPOINT messages so I'm not sure what db.atomic() actually triggers\r\n\r\nThe transactions are managed behind-the-scenes by `psycopg2`. You can see in the peewee code that it calls `rollback()` or `commit()` on the underlying psycopg2 connection object. The [managing transactions](http://docs.peewee-orm.com/en/latest/peewee/database.html#managing-transactions) document is worth reading if you're unclear on Peewee's APIs or how to use them.\r\n\r\nPeewee always runs in autocommit mode by default. That is: Peewee will issue commit unless there is an active manual_commit or atomic block wrapping the code. If you want to explicitly manage transactions/commit yourself, you wrap the corresponding code in the `manual_commit()` context manager. If you want to wrap multiple operations in a transaction or savepoint, you wrap the corresponding code in an `atomic()` context manager. Otherwise **each statement is effectively in its own transaction**.", "This might also help: http://initd.org/psycopg/docs/usage.html#transactions-control", "A few findings, should anyone read this.\r\n\r\n```python\r\n def _initialize_connection(self, conn):\r\n curs = conn.cursor()\r\n curs.execute('SET statement_timeout=\\'1s\\'')\r\n```\r\n\r\nThis opens up new transaction, because:\r\n\r\n> In Psycopg transactions are handled by the connection class. **By default, the first time a command is sent to the database (using one of the cursors created by the connection), a new transaction is created.** The following database commands will be executed in the context of the same transaction – not only the commands issued by the first cursor, but the ones issued by all the cursors created by the same connection. Should any command fail, the transaction will be aborted and no further command will be executed until a call to the rollback() method.\r\n\r\nSo, if you use the code snippet above, it opens up transaction, but does not commit. This means connection is left hanging as \"idle in transaction\" state. If you have slow processing or I/O, that means the connection is kept open / reserved for the whole of this time (as in my case, where I am calling another service that may sometimes take 10-30s to respond).\r\n\r\nIf you're not using connection pooler, then this is just fine. You reserve DB connections for the duration of connect-close cycle, anyway.\r\n\r\nHowever, I am running pgBouncer in *transaction*-pooling mode, so each connection gets served a connection to pgBouncer, but only transactions are routed to the actual PG database, so it's important when you `BEGIN`/`COMMIT`. Opening, but not committing the transaction shows as \"idle in transaction\" in PG and that transaction is then holding an actual pgBouncer->DB connection, just sitting idle, blocking others.\r\n\r\nSo commit even this statement:\r\n\r\n```python\r\n def _initialize_connection(self, conn):\r\n with conn.cursor() as curs: # auto-releases cursor, not required but nicer\r\n curs.execute('SET statement_timeout=\\'1s\\'')\r\n conn.commit() # REQUIRED\r\n```\r\n\r\nFinally, with *transaction*-pooling mode in pgBouncer, nothing actually guarantees that the `SET ...` statement would be run for each *pgBouncer->PG* connection as the first call. Any transaction may get served with pgBouncer->PG connection, which means any `SELECT`, `UPDATE` or whatever you might have there may get be served a fresh pgBouncer->PG connection, where `SET ...` wasn't actually called yet.\r\n\r\nAnd sure, `SET ...` statements leak from connection to connection, so it's completely messed up (but for me _that_ is fine as I use same `statement_timeout` for all connections, so leaking does no harm).\r\n\r\nDue to above, I tried switching to *session*-pooling mode, but faced into some potential issue with pgBouncer, ref https://github.com/pgbouncer/pgbouncer/issues/384. However, even if I managed to switch to session-pooling, it wouldn't help, because I'm opening DB connection (via peewee) when inbound (web app) request processing starts and closing it when the response is about to get returned. With session-pooling mode, I would need finer-grained connect/close cycle, again to avoid connections hanging in \"idle in transaction\" state, doing nothing (as they wait processing or I/O).\r\n\r\nSo, potential solutions here:\r\n\r\n1. Wrap all calls `with db.atomic()` to explicitly define transactions and use the suggested:\r\n\r\n class PgBouncerPostgresqlDatabase(PostgresqlDatabase):\r\n def begin(self):\r\n self.execute_sql('SET ...')\r\n\r\n However, wrapping calls in `with db.atomic()` blocks is problematic, because of code re-use and structure - you don't always know if a transaction is already open or not, so you might actually end up with nested transactions).\r\n\r\n2. Write context-manager (similar to `db.atomic()`) that connects/closes connection and wrap it over all statements (this would allow to use session-pooling... but there's no real benefit here).\r\n\r\n3. Use pgBouncer's `query_timeout` as substitute for `statement_timeout` (if it's ok, see below *)\r\n\r\n4. Use server -level `statement_timeout` (and override it when/if needed, e.g. when debugging and running potentially slow queries)\r\n\r\n5. Set `statement_timeout` in pgBouncer->DB connection via `connect_query` (`options=-c statement_timeout=...` would do the same but it's not allowed). I will go with this.\r\n\r\n*pgBouncer has `query_timeout` (broken in older versions and fixed in 1.9.0+), but it's documented as:\r\n\r\n> **query_timeout**\r\n> Queries running longer than that are canceled. This should be used **only with slightly smaller server-side `statement_timeout`**, to apply only for network problems. [seconds]\r\n\r\nSo apparently it cannot be used as a substitute for `statement_timeout` (but unfortunately, it docs don't explain why).", "Thank you for the excellent comment and sharing ur experience w/this stuff." ]

[]

[]

[ "The quick-start is supposed to be just that -- a quick start. It is nowhere near comprehensive.\r\n\r\nThe [database](http://docs.peewee-orm.com/en/latest/peewee/database.html) documentation contains tons of information:\r\n\r\n* [run-time database configuration](http://docs.peewee-orm.com/en/latest/peewee/database.html#run-time-database-configuration)\r\n* [dynamically defining a database](http://docs.peewee-orm.com/en/latest/peewee/database.html#dynamically-defining-a-database)\r\n* [setting the database at run-time](http://docs.peewee-orm.com/en/latest/peewee/database.html#setting-the-database-at-run-time)\r\n* [testing peewee applications](http://docs.peewee-orm.com/en/latest/peewee/database.html#testing)" ]

[]

[]

[ "How are you initializing your proxy? i.e., what is the database instance you are passing to it to initialize it?\r\n\r\nAdditionally, Peewee does not automatically register a user-defined regexp implementation for sqlite.", "The `playhouse.sqlite_ext.SqliteExtDatabase` *does* allow you to register a REGEXP user-defined function - [documentation](http://docs.peewee-orm.com/en/latest/peewee/sqlite_ext.html#SqliteExtDatabase):\r\n\r\n```python\r\nfrom playhouse.sqlite_ext import SqliteExtDatabase\r\n\r\n# Instantiate the sqlite-ext db, and tell it we want to register a regexp function.\r\ndb = SqliteExtDatabase('my_database.db', regexp_function=True)\r\n```\r\n\r\nUsing the standard `peewee.SqliteDatabase` it is also possible to register a user-defined function. You **do not** need to do any crazy shit like hand-editing the code. Here are the docs for registering a user-defined function: http://docs.peewee-orm.com/en/latest/peewee/api.html#SqliteDatabase.func\r\n\r\nExample:\r\n\r\n```python\r\ndb = SqliteDatabase('my_app.db')\r\n\r\[email protected]()\r\ndef regexp(expr, s):\r\n return re.search(expr, s) is not None\r\n```\r\n\r\n--------\r\n\r\nNow, regarding the use of `Proxy` - you cannot register user-defined functions using proxy database, as this is a sqlite-only feature. So you would do something like this:\r\n\r\n```python\r\ndb = Proxy()\r\n\r\n# ... define models, whatever\r\n\r\n# Whenever you actually *do* initialize your proxy db, *at that time* you would\r\n# register the user-defined regexp func.\r\nsqlite_db = SqliteDatabase('my_app.db')\r\ndb.initialize(sqlite_db)\r\n\r\[email protected]()\r\ndef regexp(expr, s):\r\n return re.search(expr, s) is not None\r\n```" ]

[]

[]

[ "Uhh, this example is damn near inscrutable. Can you make another minimal example? Like wtf is A, B, C and D, and how are they related? It seems like C and B have an \"a_id\", and then D has a \"order_id\"?", "OK, I think I've made an example that is clear.\r\n\r\n```python\r\nclass User(Base):\r\n username = TextField()\r\n\r\nclass Game(Base):\r\n user = ForeignKeyField(User)\r\n name = TextField()\r\n\r\nclass Score(Base):\r\n game = ForeignKeyField(Game)\r\n points = IntegerField()\r\n```\r\n\r\nTo get a list of users and the sum of their points across all games they've played:\r\n\r\n```python\r\n# Subquery calculates just the user id and the sum of points.\r\nsubq = (Game\r\n .select(Game.user, fn.SUM(Score.points).alias('total_points'))\r\n .join(Score, JOIN.LEFT_OUTER)\r\n .group_by(Game.user))\r\n\r\n# Query all users and get their total points.\r\nquery = (User\r\n .select(User.username, subq.c.total_points)\r\n .join(subq, on=(User.id == subq.c.user_id)))\r\n```\r\n\r\nPeewee sees that you're joining on a subquery whose primary model is `Game`. Thus, Peewee assumes we're looking at attributes and values related to the game table. Peewee attempts to reconstruct the model graph when iterating the results, so you would write:\r\n\r\n```python\r\nfor user in query:\r\n print(user.username, user.game.total_points)\r\n```\r\n\r\nIf you don't want Peewee to try and do the model-graph construction, you can simply patch all joined attributes onto the User instance via the \"objects()\" method:\r\n\r\n```python\r\nfor user in query.objects():\r\n print(user.username, user.total_points)\r\n```", "Thanks for your time, sorry for the unclear example previously. I've investigated further and discovered if there are two joins, only the model graph for the first join is constructed. See below.\r\n\r\n```\r\nclass User(Base):\r\n username = TextField()\r\n\r\nclass Game(Base):\r\n user = ForeignKeyField(User)\r\n name = TextField()\r\n\r\nclass Score(Base):\r\n game = ForeignKeyField(Game)\r\n points = IntegerField()\r\n\r\nclass ProfilePicture(Base):\r\n url = TextField()\r\n user = ForeignKeyField(User)\r\n \r\nsubq = (Game\r\n .select(Game.user, fn.SUM(Score.points).alias('total_points'))\r\n .join(Score, JOIN.LEFT_OUTER)\r\n .group_by(Game.user))\r\n\r\n# Query all users and get their total points, and their pictures.\r\n# .profile_picture is present, but .game is not.\r\nquery = (User\r\n .select(User.username, subq.c.total_points)\r\n .join(ProfilePicture, on=(User.id == ProfilePicture.user_id), attr=\"profile_picture\")\r\n .join(subq, on=(User.id == subq.c.user_id)))\r\n\r\n\r\n# Query all users and get their total points, and their pictures.\r\n# .game is present, but .profile_picture is not.\r\nquery = (User\r\n .select(User.username, subq.c.total_points)\r\n .join(subq, on=(User.id == subq.c.user_id))\r\n .join(ProfilePicture, on=(User.id == ProfilePicture.user_id), attr=\"profile_picture\"))\r\n```", "I'm not sure this is quite right:\r\n\r\n```python\r\n# Query all users and get their total points, and their pictures.\r\n# .profile_picture is present, but .game is not.\r\nquery = (User\r\n .select(User.username, subq.c.total_points)\r\n .join(ProfilePicture, on=(User.id == ProfilePicture.user_id), attr=\"profile_picture\")\r\n .join(subq, on=(User.id == subq.c.user_id)))\r\n```\r\n\r\nYou're not actually selecting any columns from the `ProfilePicture` model...\r\n\r\nAdditionally, Peewee uses join context which has to do with the last-model being joined. You probably want to modify your queries:\r\n\r\n```python\r\nquery = (User\r\n .select(User.username, subq.c.total_points)\r\n .join(subq, on=(User.id == subq.c.user_id))\r\n .switch(User)\r\n .join(ProfilePicture, on=(User.id == ProfilePicture.user_id), attr=\"profile_picture\"))\r\n```\r\n\r\nOr you could just:\r\n\r\n```python\r\nquery = (User\r\n .select(User.username, subq.c.total_points)\r\n .join_from(User, subq, on=(User.id == subq.c.user_id))\r\n .join_from(User, ProfilePicture, attr=\"profile_picture\"))\r\n```", "I think I'll give the last two approaches a try..." ]

[]

[]

[ "I appreciate the patch. I've chosen to implement it slightly differently (default to using snake case, more tests, factored table-naming into a function to use in both places it is used)." ]

[]

[]

[]

[]

[]

[ "Select queries are lazily evaluated in peewee. How else do you think it would work, given that peewee uses method chaining to build a query?\r\n\r\nSo when you are building your query -- nothing happens until you:\r\n\r\n* iterate over it\r\n* call .get() / .first() / .count() etc on it\r\n* explicitly call .execute()\r\n\r\nFor your example, you could just coerce to a list if you wanted." ]

[]

[]

[ "You can use this, from the sqlite extension: http://docs.peewee-orm.com/en/latest/peewee/sqlite_ext.html#AutoIncrementField\r\n\r\nThe info in #147 is for a very old version." ]

[]

[]

[ "Thanks, I don't know how I missed that before. Fixed.", "Thanks for the quick fix!" ]

[]

[]

[ "Huh?" ]

[]

[]

[ "I've made a slightly more compact patch for the actual implementation, plus some improvements to the docs and added a couple tests:\r\n\r\nfa8fc729f37b1ab4da420fb51f8bbc90d4074fb7" ]

[]

[]

[ "Just add a `property` or whatever:\r\n\r\n```python\r\nclass Rone(Model):\r\n @property\r\n def r2(self):\r\n return self.rtwo.get()\r\n```" ]

[]

[]

[ "You want \r\n\r\n```python\r\n# Moved to its own line for clarity.\r\nlectures = Lecture.select(Lecture.id).order_by(Lecture.created.desc()).limit(5)\r\nquery = (Attend\r\n .select()\r\n .where(Attend.lecture.in_(lectures)))\r\n```\r\n\r\nIf you plan on accessing attributes on either the `Lecture` or the `Student`, you can select them and then you will not incur an additional query to resolve the foreign-key lookup:\r\n\r\n```python\r\nlectures = Lecture.select(Lecture.id).order_by(Lecture.created.desc()).limit(5)\r\nquery = (Attend\r\n .select(Attend, Lecture, Student)\r\n .join_from(Attend, Lecture)\r\n .join_from(Attend, Student)\r\n .where(Attend.lecture.in_(lectures)))\r\n```\r\n\r\nSince you're joining, you could also just do the join on the subquery!\r\n\r\n```python\r\nlectures = Lecture.select(Lecture.id Lecture.name).order_by(Lecture.created.desc()).limit(5)\r\nquery = (Attend\r\n .select(Attend, Student, lectures.c.name)\r\n .join_from(Attend, Student)\r\n .join_from(Attend, lectures, on=(Attend.lecture == lecture.c.id))\r\n\r\n# This will only execute one query -- the foreign-keys are already loaded.\r\nfor attend in query:\r\n print(attend.student.name, attend.lecture.name)\r\n```", "It worked! Thanks for quick and clear answer!" ]

[]

[]

[ "Holy shit, Sqlite 3.6? That's like 10 years old.\r\n\r\nIt doesn't support bulk insert, so you will need to use a loop in this case." ]

[]

[]

[ "You should be able to just use `fn.FIELD()`, since FIELD is a sql function:\r\n\r\n```python\r\nmy_query = User.select().order_by(fn.FIELD(User.id, 4, 1, 3, 2))\r\n```" ]

[]

[]

[ "> The reason is that when you're splitting up a dozen or more tables, where each model gets its own file, it becomes too hard to figure out what's created first and what isn't. It's far easier to always use DeferredForeignKey and put dependent imports at the bottom.\r\n\r\nWhat you're saying, in effect, is \"I have a dependency graph but I'm too lazy to think about it\".\r\n\r\nYou have foreign-key constraints in the database, foreign-key dependencies between model classes, and import-order dependencies between Python modules. If you get the import-order figured out, you should have no trouble getting the foreign-keys to work. If this seems too hard, I'd suggest you have too many Python modules, and you might consolidate them.\r\n\r\nThat being said, this feels kinda like a bug. The reason why Peewee doesn't resolve these is because Peewee doesn't keep an internal registry of every model subclass. Deferred foreign keys are resolved as a side-effect during model class creation, which typically happens at import time.\r\n\r\nTo fix this, I'd think that Peewee (or the DeferredForeignKey class) would need to track every model class that is defined, which doesn't seem great.", "> What you're saying, in effect, is \"I have a dependency graph but I'm too lazy to think about it\".\r\n\r\nWell, we're talking about the *order of imports* mattering. That is to say, one of these might work, while the other will not:\r\n\r\n```\r\nfrom artist import Artist\r\nfrom album import Album\r\n```\r\n\r\nvs:\r\n\r\n```\r\nfrom album import Album\r\nfrom artist import Artist\r\n```\r\n\r\nThat can result in a situation where all your unittests might clear, and then when you sort your imports alphabetically, it breaks, for example. Just broadly speaking, it's my feeling that the order you import modules shouldn't matter.\r\n\r\n> To fix this, I'd think that Peewee (or the DeferredForeignKey class) would need to track every model class that is defined, which doesn't seem great.\r\n\r\nYeah, that's more or less the tree I was barking up too, and it doesn't seem great.\r\n\r\nFor the moment, my actual solution is, in the main file, is this:\r\n\r\n```\r\nfor table in all_tables:\r\n DeferredForeignKey.resolve(table)\r\n```\r\n\r\nThat verifies all the things are resolved.\r\n\r\n*As an aside:* Arguably it's a separate bug that failing to resolve a DeferredForeignKey column results in a syntax error from the database because the column type definition is missing. But to get this to happen, I had to be using uuid's.\r\n", "> Well, we're talking about the order of imports mattering. That is to say, one of these might work, while the other will not\r\n\r\nOnly because the resolution of the dependency graph has been pushed til later. Ordinarily, using regular `ForeignKeyField`, you would have to resolve your dependencies between the modules themselves in order to declare the `ForeignKeyField()` in the first place.\r\n\r\n`DeferredForeignKey` really exists for one reason: to make it possible to declare circular foreign-key dependencies. This is described where it is documented,\r\n\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#DeferredForeignKey\r\n* http://docs.peewee-orm.com/en/latest/peewee/models.html#circular-foreign-key-dependencies\r\n\r\nI'd suggest ironing out your module organization.\r\n\r\nConsider if this were not \"peewee\" but *literally any other python library* and you have all these interdependencies between the classes. You would need to resolve these types of issues if you wanted to break them out into a ton of little modules.", "I think, however, you're over-simplifying the matter as inter-dependency between classes. It is, but only at create time.\r\n\r\nIf you have a fairly modular library, or a handful of libraries, managing dependencies is one thing, but managing import order is another, especially when you can't control in what order the consumers of your library might choose to import them. I'd argue that, just like how you maintain a list (on a class attribute) in one direction for deferred foreign keys, it would make sense to do it in the other way.\r\n\r\nHaving said that, if the official Peewee solution is just to be careful about in what order you import modules, and since most editors and programmers just go with alphabetical order (I think that's even in PEP8), I'll stick with manually resolving them inside the library to avoid the ambiguity. Thanks for the thorough reply!", "Peewee model classes are apples-to-apples the same as any other python classes, functions, etc. If you have objects that depend on other objects within your collection of modules, you'll have to resolve those dependencies. Peewee models are the same as any other python objects in this regard.\r\n\r\nThe problem `DeferredForeignKey` was designed to solve is mutual dependence.\r\n\r\nUsing `DeferredForeignKey` to paste over a fragmented or poorly-thought-out dependency graph is possible, but never advisable.\r\n\r\nFor what its worth, when I have two modules that are somehow interdependent, the solution is usually to either move them into a single module - or create a third module that imports and resolves both deps.\r\n\r\nDiscussion with real examples available here: http://charlesleifer.com/blog/structuring-flask-apps-a-how-to-for-those-coming-from-django/", "Fair enough. I think your update to the docs would have also kept me going down the rabbit hole I originally went down, which was one of getting sql syntax errors because the `DeferredForeignKey` was never resolved.\r\n\r\nWhat I might say is that perhaps, *as a feature* some kind of `LazyForeignKey` that actually does what I'm describing would be useful. At least in my opinion." ]

[]

[]

[ "Pretty straightforward:\r\n\r\n```python\r\nquery = (PortInfo\r\n .select(PortInfo.state, fn.COUNT(PortInfo.ip.distinct(), PortInfo.port))\r\n .group_by(PortInfo.state))\r\n```\r\n\r\nTranslates into:\r\n\r\n```sql\r\nSELECT \"t1\".\"state\", COUNT(DISTINCT \"t1\".\"ip\", \"t1\".\"port\") \r\nFROM \"portinfo\" AS \"t1\" \r\nGROUP BY \"t1\".\"state\"\r\n```" ]

[]

[]

[ "If you don't initialize your `SqliteDatabase` instance with a database parameter, then you have to call `.init()` at a later time. By explicitly requiring `None`, it reinforces the idea that the database is not initialized yet, and the actual initialization is happening later in a call to `.init()`.", "A very clear exception is raised, and a message is logged too if the user forgets to use `.init()`:\r\n\r\n```\r\n raise InterfaceError('Error, database must be initialized '\r\npeewee.InterfaceError: Error, database must be initialized before opening a connection.\r\n```\r\n\r\nThe above error is IMHO sufficient reinforcement. Why is further reinforcement necessary?", "You can always subclass it and override\r\n\r\n```python\r\nclass SpecialSqliteDatabase(SqliteDatabase):\r\n def __init__(self, database=None, *args, **kwargs):\r\n super(SpecialSqliteDatabase, self).__init__(database, *args, **kwargs)\r\n```" ]

[]

[]

[ "Thanks for the excellent ticket -- I'll take a look.", "I cannot replicate this issue. I've added some tests which I would have thought would reveal the problem, but they are passing without issue: ea12dadf5f370e470e05c760c02be4e7dca1edcd\r\n\r\nIf you can comment / share a test-case that replicates the problem, I will reopen.", "@coleifer thanks for your time. I can reproduce this issue in my notebook but it's messy now, will provide updated tests after some digging.\r\n\r\n@NicolasCaous first, you wrong, database is initialized properly. Second, you're pretty rude, man. I have provided just enough data to get maintainer's answer that's not an expected behaviour in some way.", "At the time of `Task.select` execution `CreateUser` field is not resolved yet. I'd expect `DeferredForeignKey` to act like `IntegerField` (*_id) in those situations. Or maybe some note should be added to the docs.\r\n\r\n```\r\nfrom playhouse import postgres_ext as pw\r\nfrom playhouse.pool import PooledPostgresqlExtDatabase\r\nfrom playhouse.postgres_ext import (ArrayField, AutoField, CharField,\r\n DateTimeField, DeferredForeignKey,\r\n ForeignKeyField, IntegerField)\r\nfrom psycopg2.extras import DictCursor\r\n\r\npg_main = PooledPostgresqlExtDatabase(\r\n None,\r\n timeout=180,\r\n stale_timeout=900,\r\n max_connections=32,\r\n cursor_factory=DictCursor\r\n)\r\n\r\npg_main.init(\r\n database='postgres',\r\n user='postgres',\r\n password=None,\r\n host='172.17.0.5',\r\n port=5432\r\n)\r\n\r\nclass Task(pw.Model):\r\n ID = AutoField(column_name='id')\r\n UpdateDate = DateTimeField(column_name='updatedt', null=True)\r\n CreateDate = DateTimeField(column_name='createdt', null=True)\r\n State = IntegerField(column_name='state', default=0)\r\n CreateUser = DeferredForeignKey('User', column_name='createuser', null=True, field='ID', index=False)\r\n UpdateUser = DeferredForeignKey('User', column_name='updateuser', null=True, field='ID', index=False)\r\n \r\n class Meta:\r\n database = pg_main\r\n table_name = 'tasks'\r\n\r\n# class User(pw.Model):\r\n# ID = AutoField(column_name='id')\r\n# UpdateDate = DateTimeField(column_name='updatedt', null=True)\r\n# CreateDate = DateTimeField(column_name='createdt', null=True)\r\n# State = IntegerField(column_name='state', default=0)\r\n# CreateUser = IntegerField(column_name='createuser', null=True, index=False)\r\n# UpdateUser = IntegerField(column_name='updateuser', null=True, index=False)\r\n \r\n# class Meta:\r\n# database = pg_main\r\n# table_name = 'users'\r\n \r\nwith pg_main:\r\n# User.drop_table()\r\n# User.create_table()\r\n# Task.drop_table()\r\n# Task.create_table()\r\n tsk = Task.select().first()\r\n```", "Yeah I removed his comments. I was not being sarcastic when I said this was an excellent ticket.\r\n\r\nOk I didn't think about the possibility that you would attempt a query before all the models were imported / eval'd. I'll take another look.", "Honestly, I kinda feel like attempting to query with an unresolved deferred foreign-key should be an error. But for now, I've just decided to carry forward the column name, so that it works as you'd expect." ]

[]

[]

[ "First: format your code. PLEASE. Here is a link: https://guides.github.com/features/mastering-markdown/\r\n\r\nSecond: you have two foreign-keys pointing to `User`. You need to specify a name for the back-reference that doesn't collide.\r\n\r\nIn your example, I would do something like:\r\n\r\n```python\r\nsender = ForeignKeyField(User, backref='outbox')\r\nreceiver = ForeignKeyField(User, backref='inbox')\r\n```\r\n\r\nThen you would do:\r\n\r\n```python\r\nuser = User(...)\r\nfor message in user.outbox: # Messages where \"user\" is \"message.sender\"\r\n # ...\r\n\r\nfor message in user.inbox: # Messages where \"user\" is \"message.receiver\"\r\n # ...\r\n```" ]

[]

[]

[ "Seems like I can do this, but I'm not sure if this is correct or not:\r\n\r\n```python\r\nEXCLUDED = Entity('EXCLUDED') \r\n```", "I mistakenly thought that `EXCLUDED` only applied to the SET part...didn't realize it could also be used in the `WHERE` portion. Thanks, I will put together a fix.", "Fixed. Docs along with examples are now online: http://docs.peewee-orm.com/en/latest/peewee/api.html#EXCLUDED\r\n\r\nIt is exported if you use `from peewee import *`, or you can use `from peewee import EXCLUDED`." ]

[]

[]

[ "Peewee ```3.9.2``` \r\nPsycopg2 ```2.7.7```\r\n", "Are you messing with `._connections` in any way? The `._connections` list is a heap of `(timestamp, conn)` 2-tuples.\r\n\r\nPerhaps the issue is that there are two connections in the `_connections` heap with the exact same timestamp (down to the microsecond?).\r\n\r\nCan you replicate this?", "I just followed the steps from the docs( ```http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#connection-pool```)\r\n\r\nThis is the full traceback.\r\n```\r\n[2019-03-13 19:36:23,065] - [CP Server Thread-19] - [ERROR - app.py] Exception on /api/v1/test \r\nTraceback (most recent call last):\r\n File \"D:\\Python36_x64\\test_project\\lib\\site-packages\\flask\\app.py\", line 2292, in wsgi_app\r\n response = self.full_dispatch_request()\r\n File \"D:\\Python36_x64\\test_project\\lib\\site-packages\\flask\\app.py\", line 1815, in full_dispatch_request\r\n rv = self.handle_user_exception(e)\r\n File \"D:\\Python36_x64\\test_project\\lib\\site-packages\\flask\\app.py\", line 1718, in handle_user_exception\r\n reraise(exc_type, exc_value, tb)\r\n File \"D:\\Python36_x64\\test_project\\lib\\site-packages\\flask\\_compat.py\", line 35, in reraise\r\n raise value\r\n File \"D:\\Python36_x64\\test_project\\lib\\site-packages\\flask\\app.py\", line 1811, in full_dispatch_request\r\n rv = self.preprocess_request()\r\n File \"D:\\Python36_x64\\test_project\\lib\\site-packages\\flask\\app.py\", line 2087, in preprocess_request\r\n rv = func()\r\n File \"D:\\Projects\\test_project\\test_api\\server.py\", line 135, in _db_connect\r\n test_api.libs.models.database.connect()\r\n File \"D:\\Python36_x64\\test_project\\lib\\site-packages\\playhouse\\pool.py\", line 108, in connect\r\n return super(PooledDatabase, self).connect(reuse_if_open)\r\n File \"D:\\Python36_x64\\test_project\\lib\\site-packages\\peewee.py\", line 2777, in connect\r\n self._state.set_connection(self._connect())\r\n File \"D:\\Python36_x64\\test_project\\lib\\site-packages\\playhouse\\pool.py\", line 125, in _connect\r\n ts, conn = heapq.heappop(self._connections)\r\nTypeError: '<' not supported between instances of 'psycopg2.extensions.connection' and 'psycopg2.extensions.connection'\r\n```\r\n\r\nI have a CheeryPy Server, with 100 threads, that is based on a Flask App.\r\nThe PooledPostgresqlDatabase configuration is: `max_connections=50, stale_timeout=300`", "Can you inspect the error a bit?\r\n\r\n```python\r\ntry:\r\n test_api.libs.models.database.connect()\r\nexcept TypeError:\r\n print(test_api.libs.models.database._connections)\r\n```", "There are multiple connections with the same timestamp\r\n```\r\n[\r\n (1552507043.5142784, ....),\r\n (1552507043.498655, ....),\r\n (1552507043.498655, ....),\r\n (1552507043.5142784, ....)\r\n]\r\n```", "Can you also show the connections in the tuple? I'd like to see whether the connections are also the same.", "The connections aren't the same. They have different ids.", "All of the connections are different", "Perfect, thanks. I wonder if there's a race condition? Two of the same timestamps, down to the microsecond, is just hard for me to imagine in the course of ordinary usage.\r\n\r\nCan you tell me how you're replicating this? Any and all information you can provide will help.\r\n\r\nHow are you triggering the error, for instance? Thanks", "Additionally, if you could enable pool logging, by adding the following:\r\n\r\n```python\r\nimport logging\r\nlogger = logging.getLogger('peewee.pool')\r\nlogger.addHandler(logging.StreamHandler())\r\nlogger.setLevel(logging.DEBUG)\r\n```\r\n\r\nThat would provide some visibility into what might be causing the issue.\r\n\r\nSo:\r\n\r\nWhat steps do you follow to replicate this? i.e., does it happen on startup, or if you make a bunch of requests, or what?\r\n\r\nCould you try adding the logging and do whatever to trigger the issue?\r\n\r\nThank you.", "For example, I've tried spinning up a bunch of threads and in each one opening and closing a pool connection several times. I've tried this with a max connections higher and lower than the thread count (lower so that there is contention and some threads have to block while waiting for a connection). I haven't seen any issues so far.\r\n\r\n```python\r\nfrom peewee import *\r\nfrom playhouse.pool import PooledPostgresqlDatabase\r\n\r\ndb = PooledPostgresqlDatabase('peewee_test', max_connections=10,\r\n timeout=10)\r\n\r\nimport threading\r\nimport time\r\n\r\ndef open_sleep_close():\r\n for _ in range(10):\r\n with db: # Hold the connection open for 1/10th of a second.\r\n time.sleep(0.1)\r\n\r\nthreads = [threading.Thread(target=open_sleep_close) for _ in range(50)]\r\nfor t in threads:\r\n t.start()\r\n\r\nprint('waiting...')\r\nfor t in threads:\r\n t.join()\r\n\r\nprint('- in use? %s' % len(db._in_use)) # prints 0\r\nprint('- available? %s' % len(db._connections)) # prints 10 (or whatever max connections is set to).\r\n```", "The exception occurs after half an hour the server has started. The server receives some kind of heartbeats from other scripts. It isn't usually flooded with requests. When the exception occurs, from what I can see in the logs, the server isn't flooded with requests. At the second when the exception occurs, there are 3 or 4 requests.", "And another interesting fact is that the server runs on two different hosts and the exception appears just on one of the hosts.", "I have added the logger of peewee and I don't see something unusual in the logs. Just creation of connection when none are available, closing connections because they are stale, retrieving connections from the pool and returning connection to the pool.\r\nMeanwhile, the exception still occurs.", "> I have added the logger of peewee and I don't see something unusual in the logs. Just creation of connection when none are available, closing connections because they are stale, retrieving connections from the pool and returning connection to the pool.\r\n> Meanwhile, the exception still occurs.\r\n\r\nThis is not very helpful. I didn't want your \"interpretation\" of the logs, but the logs themselves, especially in the times leading up to (and including) the exception occurring.\r\n\r\nSimilarly, if you could share your database declaration with me -- e.g., what parameters you're using to invoke the DB?\r\n\r\nI think this is just something weird in your setup, but I'd like to be as thorough as possible, and for that I need you to help by providing information.", "Please comment with more information: what settings are you using with your database (stale timeout, Max conns, timeout, etc). It'd be really helpful to see the pool logs as well.\r\n\r\nAs I can't replicate the problem I'm closing for now. If you can provide more information I'll gladly reopen." ]

[]

[]

[ "I am going to try\r\n\r\nfrom playhouse.signals import Model, pre_save\r\n\r\nclass MyModel(Model):\r\n data = IntegerField()\r\n\r\n@pre_save(sender=MyModel)\r\ndef on_save_handler(model_class, instance, created):\r\n # find max value of temp_id in model\r\n # increment it by one and assign it to model instance object\r\n next_value = MyModel.select(fn.Max(MyModel.temp_id))[0].temp_id +1\r\n instance.temp_id = next_value\r\n\r\nwhich seems likely to work ... though rather involved perhaps ...", "You use sequences for that.\r\n\r\n```python\r\nmy_field = IntegerField(sequence='my_field_seq')\r\n```" ]

[]

[]

[ "Sry，I miss applying the wrapper in some functions.", "Running each request in a new thread is kinda silly...but ok? Presumably your wsgi server would handle all that. So you're probably running threads-in-threads?\r\n\r\nAnyway...ok?" ]

[]

[]

[ "Pickle doesn't like the fact that you've nested your `User` model inside the `class Database`. Consider reorganizing your code. It will work fine to pickle Peewee model classes and instances (though this is really not advisable!), but not in the way you have written your code.\r\n\r\nA couple other things to mention:\r\n\r\n* `BigIntegerField(primary_key=True)` requires you to manually specify the IDs (assuming you plan to create new rows). For auto-incrementing you would use `BigAutoField()` instead.\r\n* Peewee model classes can already be used like dictionaries. So, `User[1]` would return the user with id=1.", "Hi @coleifer , thank you for your reply, I made some changes to the code but it is still not working. I made a test code for you to evaluate:\r\n\r\nusers.py\r\n```\r\nfrom datetime import datetime\r\nimport os\r\nfrom peewee import *\r\n\r\n# Global database object\r\nDB = SqliteDatabase(None)\r\n\r\nclass Database:\r\n db = None\r\n same_url_limit = 1 # Defines how many same urls are allowed, e.g., in cases of group projects this may be 2\r\n logger = None\r\n db_filename = None\r\n\r\n def __init__(self, logger=None, db_filename='database.sqlite3'):\r\n self.db_filename = db_filename\r\n self.logger = logger\r\n self.db = DB\r\n self.db.init(db_filename)\r\n self.db.connect()\r\n self.db.create_tables([Users])\r\n os.chmod(db_filename, 0o666)\r\n\r\n def __del__(self):\r\n\r\n self.db.close()\r\n\r\n\r\nclass Users(Model):\r\n \"\"\"\r\n The class containing local information obtained through canvas about each user, assignment status, last commit,\r\n plagiarism status and other important information for ATHINA to function.\r\n \"\"\"\r\n user_id = BigIntegerField(primary_key=True)\r\n course_id = BigIntegerField(default=0)\r\n\r\n class Meta:\r\n database = DB\r\n```\r\n\r\ntester.py\r\n```\r\nfrom users import *\r\nimport multiprocessing\r\n\r\n\r\nclass Tester:\r\n user_data = None\r\n\r\n def __init__(self, user_data):\r\n self.user_data = user_data\r\n\r\n def test(self, test):\r\n print(test)\r\n\r\n def parallel_map(self, user_ids):\r\n compute_pool = multiprocessing.Pool(processes=2)\r\n user_object_results = compute_pool.map(self.test, user_ids)\r\n return user_object_results\r\n\r\ntester = Tester(Database('file.sqlite3'))\r\ntester.parallel_map([1,2,3])\r\n```\r\n\r\nI am getting the following error:\r\n```\r\nTraceback (most recent call last):\r\n File \"tester.py\", line 20, in <module>\r\n tester.parallel_map([1,2,3])\r\n File \"tester.py\", line 16, in parallel_map\r\n user_object_results = compute_pool.map(self.test, user_ids)\r\n File \"/usr/lib/python3.5/multiprocessing/pool.py\", line 260, in map\r\n return self._map_async(func, iterable, mapstar, chunksize).get()\r\n File \"/usr/lib/python3.5/multiprocessing/pool.py\", line 608, in get\r\n raise self._value\r\n File \"/usr/lib/python3.5/multiprocessing/pool.py\", line 385, in _handle_tasks\r\n put(task)\r\n File \"/usr/lib/python3.5/multiprocessing/connection.py\", line 206, in send\r\n self._send_bytes(ForkingPickler.dumps(obj))\r\n File \"/usr/lib/python3.5/multiprocessing/reduction.py\", line 50, in dumps\r\n cls(buf, protocol).dump(obj)\r\nTypeError: can't pickle _thread.lock objects\r\n\r\n```", "Is that `_thread.lock` coming from peewee? It's not clear to me. Your code organization is kind of fucked.\r\n\r\nLook: here is a minimal example with none of this crazy shit, and it works fine:\r\n\r\n```python\r\nfrom multiprocessing import Pool\r\nfrom peewee import *\r\n\r\ndb = SqliteDatabase('/tmp/test-mp.db')\r\n\r\nclass Register(Model):\r\n value = IntegerField()\r\n class Meta:\r\n database = db\r\n\r\nwith db:\r\n db.drop_tables([Register])\r\n db.create_tables([Register])\r\n\r\n\r\ndef create_register(i):\r\n with db:\r\n Register.create(value=i)\r\n\r\nPool(processes=4).map(create_register, range(10))\r\n\r\nwith db:\r\n for row in Register.select().order_by(Register.id):\r\n print(row.id, row.value)\r\n```", "I suspect that thread_lock comes from peewee. It makes sense that the sqlite connection won't be sharable to other threads. The issue is that I need to have separate modules and separate the db logic with my tester module. The problem is that if the self is passed on the mapped function and that contains the connection then you get that error. There is a work around.\r\n\r\nBefore calling pool, I close the database (del has an alias that closes it) and I connect to the db from within the function. I get multiple connections to the same file but it would be the same like running several python scripts that do operations on the same sqlite db.\r\n\r\n```\r\nfrom users import *\r\nimport multiprocessing\r\n\r\n\r\nclass Tester:\r\n user_data = None\r\n\r\n def __init__(self, user_data):\r\n self.user_data = user_data\r\n\r\n def test(self, test):\r\n self.user_data = Database('file.sqlite3')\r\n print(Users[1])\r\n print(test)\r\n Users[1].course_id = 1\r\n Users[1].save()\r\n del self.user_data\r\n return True\r\n\r\n def parallel_map(self, user_ids):\r\n compute_pool = multiprocessing.Pool(processes=2)\r\n user_object_results = compute_pool.map(self.test, user_ids)\r\n return user_object_results\r\n\r\ntester = Tester(Database('file.sqlite3'))\r\n#Users(user_id=1).save(force_insert=True)\r\nUsers[1]\r\ndel tester.user_data\r\ntester.parallel_map([1, 2, 3])\r\ntester.user_data = Database('file.sqlite3')\r\n```", "I *feel* like I'm speaking english and my code was clear and concise.", "One more thought: when you fork, any open connections are carried into the new process. Which usually results in bad things happening when you try to use them from the child process. So: **always** close connections before fork. The same applies to pickling connections.\r\n\r\nBasically: if you want to do multiple processes, always try to minimize the database state (eg open conns) before fork. " ]

[]

[]

[ "```python\r\nWeathervalue._meta.table_name = self.selectedstation+'_weathervalue'\r\ndel Weathervalue._meta.table # Remove cached table property, will regenerate\r\n```\r\n\r\nCan you test making the addition above?", "Issue resolved. According to the documentation, I needed to create a table model for each table in the database in this case 2 tables even though fields are identical. I added the table name in the table model in the meta field. Based on which one I selected I accessed the corresponding table model. I originally created only one table model for both which didn't worked. \r\n\r\nI noted in the context manager when using the with statement it doesn't properly close the database connection as I was able to verify with the db.is_closed() statement. I needed to add the db.close() to close the connection. Should I create a separate issue for this?", "> I noted in the context manager when using the with statement it doesn't properly close the database connection as I was able to verify with the db.is_closed() statement. I needed to add the db.close() to close the connection. Should I create a separate issue for this?\r\n\r\nThis is tested. Probably some issue on your end:\r\n\r\nhttps://github.com/coleifer/peewee/blob/master/tests/database.py#L165-L186", "Thanks. It is probably in my code the way I initialized the database. I will look at it again. " ]

[]

[]

[ "I'll pass. Plus you've got tests failing due to unbound fields not having a `model` attribute." ]

[]

[]

[ "NULLS is not supported by Sqlite. For SQLite you can use a case expression, however: http://docs.peewee-orm.com/en/latest/peewee/api.html#Case", "I've added a feature check and compatibility layer so that you can specify ``nulls='first'`` or ``nulls='last'`` with any database, and Peewee will generate the appropriate SQL. For postgres, it uses the usual non-standard ``nulls first/last``, but for sqlite and mysql, an equivalent ``CASE`` statement will be generated.", "Awesome, thanks a lot!" ]

[]

[]

[ "Thanks for the quick report. This should be fixed -- I had been testing against pymysql and neglected to handle `MySQLdb` correctly.\r\n\r\nI've pushed 3.9.1 which contains the fix." ]

[]

[]

[ "This relates to the following code:\r\n\r\n```python\r\n def python_value(self, value):\r\n if value is not None and isinstance(value, (int, float, long)):\r\n if value == 0:\r\n return\r\n```\r\n\r\nI suppose this is a bug, so I've removed the \"if value == 0\" conditional.\r\n\r\nMy original thinking was that a zero timestamp is a special-case which was equivalent to \"no timestamp\". But even if that is true, the use of NULL/None carries consequences that are not present when using a zero value. Should be fixed by df94b2db9fa93b0f56cbca2f95b2bf42ba27bb01", "Awesome, thanks! I kinda figured it was something like that.\r\n\r\nThe only reason that I ran into the issue is because I was testing my own program and noticed that I couldn't fix particular edge case without some hacks." ]

[]

[]

[ "From the [docs](http://docs.peewee-orm.com/en/latest/peewee/database.html):\r\n\r\n> The Database initialization method expects the name of the database as the first parameter. Subsequent keyword arguments are passed to the underlying database driver when establishing the connection, allowing you to pass vendor-specific parameters easily.\r\n\r\n```python\r\ndb = PostgresqlDatabase('my_db', sslmode='require', ...etc...)\r\n```", "I am using Flask, see below. I am unsure how to pass in the sslmode require into my configuration. Does not seem the call above is something I can do. Also I tried using SSLify ... but that does not seem to be putting sqlmode require on for postgres.\r\n\r\n\r\n\r\n----------------\r\n# here is my app code to startup ...\r\n\r\nfrom __future__ import print_function\r\n\r\nimport json\r\nimport logging\r\nimport os\r\n\r\nfrom flask import Flask\r\nfrom flask_caching import Cache\r\nfrom flask_peewee.db import Database\r\nfrom flask_sslify import SSLify\r\nfrom flask_htmlmin import HTMLMIN\r\n\r\nfrom peewee import PostgresqlDatabase\r\n\r\ntry:\r\n theapp_app = Flask(__name__)\r\n theapp_app.config['MINIFY_PAGE'] = True\r\n htmlmin = HTMLMIN(theapp_app)\r\n \r\n theapp_app.logger.setLevel(logging.ERROR)\r\n # theapp_app.logger.setLevel(logging.INFO)\r\n theapp_app.debug = False\r\n sslify = SSLify(theapp_app)\r\n theapp_app.jinja_env.globals.update(len=len, dumps=json.dumps)\r\n if 'ON_HEROKU' in os.environ:\r\n theapp_app.config.from_object('theapp_config.ProductionConfig')\r\n cache = Cache(theapp_app, config={'CACHE_TYPE': 'filesystem', 'CACHE_DIR': 'cache'})\r\n else:\r\n theapp_app.config.from_object('theapp_config.DevelopmentConfig')\r\n cache = Cache(theapp_app, config={'CACHE_TYPE': 'simple'})\r\n db = Database(theapp_app)\r\n # TODO: how to pass sslmode into the current setup above ... \r\n # sslmode='require' as an option ... for heroku\r\n # Example: but how to use flask theapp_app above\r\n # db = PostgresqlDatabase('my_app', user='postgres', password='secret', host='10.1.0.9', port=5432)\r\n\r\nexcept Exception as e:\r\n print(\"Exception: \" + str(e))", "So I am trying the following, as I am on heroku which binds the environment variable DATABASE_URL\r\nif is_running_on_heroku():\r\n class ProductionConfig(BaseConfig):\r\n def __init__(self):\r\n pass\r\n\r\n urlparse.uses_netloc.append('postgres')\r\n url = urlparse.urlparse(os.environ['DATABASE_URL'])\r\n DATABASE = {\r\n 'name': url.path[1:],\r\n 'user': url.username,\r\n 'password': url.password,\r\n 'host': url.hostname,\r\n 'port': url.port,\r\n 'engine': 'peewee.PostgresqlDatabase',\r\n 'sslmode':'require' # see if we can get sslmode for heroku on\r\n }\r\n DEBUG = False\r\n\r\n\r\n base_url = ra_config[\"base_url\"]\r\nelse:\r\n base_url = ra_config[\"ra\"][\"local_base_url\"]\r\n\r\n\r\nand I think that as password and other args are somehow passed into the database that I can also put sslmode here and it will float along in also ...", "Yes. If you look at the code you can see that parameters from the database config dict are passed to the Peewee database constructor." ]

[]

[]

[ "Yes, this is expected. You need to provide dictionaries with the *same* keys and values (or tuples of the same length). When you issue a SQL bulk insert, you list the expected columns, then the tuples of values, e.g.:\r\n\r\n```sql\r\ninsert into tbl_name (cola, colb, colc) values (?, ?, ?), (?, ?, ?), (?, ?, ?)\r\n```\r\n\r\nSo you list that you're inserting into \"tbl_name\" (columns \"a\", \"b\" and \"c\"). You need to provide values for all 3 columns for each row inserted.\r\n\r\nIf columns are not explicitly specified when doing a bulk insert with Peewee, then Peewee inspects the first row being inserted to derive the list of columns being inserted. Your second example, Peewee would assume you are inserting values for columns \"email\" and \"first_name\".\r\n\r\nSo you're trying to do:\r\n\r\n```sql\r\ninsert into testaccount (email, first_name) values (?, ?), (?, <error! no value>)\r\n```\r\n\r\nWhich doesn't work.\r\n\r\nJust make sure your dictionaries all contain the same fields *or* explicitly specify the fields you wish to insert.\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/api.html#Model.insert_many" ]

[]

[]

[ "So if you are exiting/terminating your Python process, there's no need to call `close_idle()` because the process will exit anyways, closing everything.\r\n\r\nI'm not sure what's going on as far as when the subprocesses are getting forked (before or after the connection pool is initialized? hopefully before). Or what the shutdown/restart behavior is... Or what kinds of queries would trigger the errors you're observing... So many questions. Could this just a timing issue where your db isn't ready when you're attempting to connect/query?\r\n\r\nIf you can reproduce this reliably without requiring docker or uwsgi or bottle web framework (e.g., just peewee and postgres) I'll reopen." ]

[]

[]

[ "For reference (for anyone googling this) if you want to drop a table in MySQL without regard to its foreign key constraints, you can temporarily [`SET FOREIGN_KEY_CHECKS = 0`](https://stackoverflow.com/a/8538716/2438538). Something like this:\r\n\r\n```python\r\n# disable foreign key checks (lasts for this session only)\r\ndb.execute_sql(\"SET FOREIGN_KEY_CHECKS=0\")\r\n\r\n# drop any tables as usual\r\ndb.drop_tables([ModelA, ModelB])\r\n\r\n# (optionally) re-enable foreign key checks\r\ndb.execute_sql(\"SET FOREIGN_KEY_CHECKS=1\")\r\n```", "This is a consequence of using an ill-advised database schema.\r\n\r\nPeewee's migrations module (`playhouse.migrate`; ([docs](http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#migrate)) contains helpers for dropping foreign-key constraints, but in the case of a circular FK you'll need to disable the constraint check like you have in your example." ]

[]

[]

[ "`is_closed` is implemented on `peewee.Database` in `peewee.py`. What it does is check whether there is a connection already open (for the current thread, if you're using multiple threads).\r\n\r\nThe logic of `manual_close` could be described in this way:\r\n\r\n1. does the current thread have a connection open? If not, there's nothing to do - return `False`\r\n2. get a reference to the currently-open connection\r\n3. remove the connection from the list of connections currently-in-use by the pool\r\n4. call the `Database.close()` method, which resets the connection state and internally calls `._close()`, which is overridden by the pool subclass.\r\n5. (inside `_close()`) this is overridden by the pool subclass to recycle the conn, which will not happen as the conn is no longer marked as being in-use\r\n6. call `_close()` again, this time with a flag indicating that yes -- we really want to close the connection -- at which point it will be closed.\r\n\r\nThe symptoms you are describing do not make a lot of sense to me... Are you using a multi-threaded application? If so, then `is_closed()` is with respect to the current thread, and maybe you're calling it from a different thread.\r\n\r\nSomething is definitely weird in your app or your setup. For instance, I use the peewee pooled database on a handful of flask apps and it is quite well-behaved -- doesn't leak conns, etc. Your stale timeout of 1 second seems odd, but shouldn't be causing the issue.\r\n\r\nYou can always turn on logging:\r\n\r\n```python\r\nimport logging\r\nlogger = logging.getLogger('peewee.pool')\r\nlogger.addHandler(logging.StreamHandler())\r\nlogger.setLevel(logging.DEBUG)\r\n```\r\n\r\nAlso note the pool is unit-tested.\r\n\r\nIf you can post some more information indicating this is a bug, or a minimal script that reproduces the issue, I will gladly reopen the issue." ]

[]

[]

[ "So this change completely fucks the 3.8 tests and the solution is to mark it as \"allow failures\"? Nope.", "OK, I owe you an apology actually, as the psycopg2 driver installation seems to be failing on 3.8 regardless of any other changes. Sorry about that." ]

[]

[]

[ "I think that I have a solution to your problem. But I warn you, I'm quite a inexperienced programmer and this is monkey patching (I know, I know, shame on me, but it works!). So take this solution with a grain of salt.\r\n\r\nI have implemented this months ago, so I don't really know what it is doing under the hood anymore. The trick is that I have implemented a helper called `metaclass_resolver` to get rid of the `metaclass conflict` and inherit from N metaclasses with no problems.\r\n\r\n# The code\r\n\r\n```\r\ndef metaclass_resolver(*classes):\r\n metaclass = tuple(set(type(cls) for cls in classes))\r\n metaclass = (\r\n metaclass[0]\r\n if len(metaclass) == 1\r\n else type(\"_\".join(mcls.__name__ for mcls in metaclass), metaclass, {})\r\n ) # class M_C\r\n return metaclass(\"_\".join(cls.__name__ for cls in classes), classes, {})\r\n```\r\n\r\n### Usage\r\n\r\n```\r\nPython 3.7.2 (default, Dec 26 2018, 08:50:25) \r\n[GCC 6.4.0] on linux\r\nType \"help\", \"copyright\", \"credits\" or \"license\" for more information.\r\n>>> from util.metaclass_resolver import metaclass_resolver\r\n>>> from peewee import *\r\n>>> \r\n>>> from abc import ABC\r\n>>> \r\n>>> class dummy(metaclass_resolver(ABC, Model)): pass\r\n...\r\n>>> issubclass(dummy, ABC)\r\nTrue\r\n>>> issubclass(dummy, Model)\r\nTrue\r\n```\r\n\r\n# Real Usage Case\r\n\r\nTo show that this (somewhat) works, I will share how this is working in my current system.\r\n\r\nEvery table `table_name` on my database has a sibling called `table_name_history` to keep track of all the changes on the table. To do this, I'm using a simple inheritance to create the columns:\r\n\r\n```\r\nclass BaseModel(Model):\r\n ...\r\n\r\nclass BaseHistory(Model):\r\n ...\r\n\r\nclass Dummy(BaseModel):\r\n dummy_field = DummyPeeweeField()\r\n\r\nclass DummyHistory(Dummy, BaseHistory):\r\n dummy = ForeingKeyField(Dummy)\r\n```\r\n\r\nThe problem was that I couldn't inherit unique fields, as they would need to be not unique in the history table.\r\n\r\nI resorted to monkey patching a metaclass to remove the unique constraint when the class was beeing loaded.\r\n\r\n```\r\nclass UniqueFieldFixMeta(type):\r\n def __init__(cls, name, bases, clsdict):\r\n if (\r\n name != \"UniqueFieldFix\"\r\n and name != \"Model_UniqueFieldFix\"\r\n and name != \"BaseHistory\"\r\n ):\r\n print(\"Fixing history unique columns for\")\r\n print(cls)\r\n for key, value in cls._meta.fields.items():\r\n value.unique = False\r\n super(UniqueFieldFixMeta, cls).__init__(name, bases, clsdict)\r\n\r\n\r\nclass UniqueFieldFix(metaclass=UniqueFieldFixMeta):\r\n pass\r\n```\r\n\r\nNow, the `BaseHistory` looks like this:\r\n\r\n```\r\nclass BaseHistory(metaclass_resolver(Model, UniqueFieldFix)):\r\n ...\r\n```\r\n\r\nAnd it works wonderfully.\r\n\r\n### Please, More Salt Sir\r\n\r\nAgain, I don't really know if this is what you are looking for. If it is, you need to be comfortable with some monkey patching. I'm just a script kid.", "a", "What happened to the issue? @efake2002", "The original comment:\r\n\r\n-------------------------------\r\n\r\nHi.\r\n\r\nFirst of all, thanks for this amazing library. It's helped and simplified our work a lot.\r\n\r\nThis is closely related to #1722 but not quite the same.\r\n\r\nIn #1722, @coleifer told us that he would not be implementing support for the abstract base class module that Python 3 provides built-in. I respect your decision to not implement it. It's your library and your personal choice.\r\n\r\nCurrently, if we try to inherit from both ABC and Peewee's Model class like so:\r\n\r\nclass AbstractModel(ABC, peewee.Model):\r\nit throws this error:\r\n\r\nTypeError: metaclass conflict: the metaclass of a derived class must be a (non-strict) subclass of the metaclasses of all its bases\r\nAre there any work arounds for this on our side? My team really needs this functionality to define abstract models with the orm. We have a ton of models and we need some way to distinguish between the abstract and the concrete models we're creating. Therefore, is there any way to implement this on our side? What is the easiest way of doing this in relation to peewee?\r\n\r\nI know that Django provides this functionality and I'd like to implement something similar as well. Something like https://docs.djangoproject.com/en/2.1/topics/db/models/#meta-inheritance would be amazing for us. Please let me know how we can accomplish this.\r\n\r\nSome of my team members are considering moving to some other orm like Pony because of this issue, but we really love this library and would prefer to stay if there was some work around for this. Please let me know.\r\n\r\nThanks for your time and any help is much appreciated!", "> Some of my team members are considering moving to some other orm like Pony because of this issue, but we really love this library and would prefer to stay if there was some work around for this. Please let me know.\r\n\r\nI love it when people say that they're \"thinking about switching to <other project>\" to try and get my attention. By all means, have fun with a magical ORM that decompiles generator expression bytecode and is 99% magic!", "(I know, everyone hates comments on closed issues, but)\r\n\r\nIf anyone gets directed here via Google, abstraction of peewee's Model class _is_ possible. You just have to use the `ABCMeta` class vs an `ABC` subclass.\r\n\r\nSo you can do something like this:\r\n\r\n```\r\nfrom abc import ABCMeta, abstractmethod\r\nfrom peewee import Model\r\n\r\nclass BaseModel(Model):\r\n __metaclass__ = ABCMeta\r\n\r\n @abstractmethod\r\n def some_method(self):\r\n pass\r\n\r\n ...\r\n\r\nclass SecondBaseModel(BaseModel):\r\n __metaclass__ = ABCMeta\r\n\r\n @abstractmethod\r\n def some_other_method(self):\r\n pass \r\n\r\n ...\r\n\r\n# ^ etc\r\n\r\nclass Dummy(SecondBaseModel):\r\n dummy_field = DummyPeeweeField()\r\n\r\n def some_method(self):\r\n ...\r\n\r\n def some_other_method(self):\r\n ...\r\n\r\n```\r\n\r\nIDE's don't seem to like this (lol) and you may have to re-state the abstract functions down your sub classes. However, this definitely runs!\r\n\r\nEdit: Formatting / grammar" ]

[]

[]

[ "Those test failures are likely due to your using an absolutely ancient version of sqlite. This ancient version of sqlite does not seem to support bulk insert. That is the problem. Upgrade sqlite to a newer version." ]

[]

[]

[]

[]

[]

[ "If you're using Postgres or a recent-ish sqlite, you can try to use the `ValuesList` with a common table expression in an UPDATE query. Postgres also supports UPDATE FROM which could also work. You can see an example here, as I've added a testcase: c1b6e5f8c5a2b6799f24b2df8788f43a0ba8811d" ]

[]

[]

[ "Nevermind, I made a mistake in my code and `ModelAModelB` was not `ModelAModelB`." ]

[]

[]

[ "The error occurs because you're passing a string as the value of a `TimestampField`. I'm not sure where your data is coming from or what form it is in, but you should probably convert it to either a python `datetime.datetime` object or an integer/float timestamp." ]

[]

[]

[ "You're using \"colon\" to separate the parameters? Is this just a typo in the code you've provided? You need equals signs.\r\n\r\nYour code:\r\n\r\n```python\r\nclass Driver(Model):\r\n SiteId: BigIntegerField(null=True)\r\n DriverId: IntegerField(null=False)\r\n```\r\n\r\nCorrect code:\r\n\r\n```python\r\nclass Driver(Model):\r\n SiteId = BigIntegerField(null=True)\r\n DriverId = IntegerField(null=False)\r\n```", "Thanks! now it's working fine...my fault!!" ]

[]

[]

[ "Your snippet is opening and closing a database connection at every request. There is an overhead time built into it (You can't escape it). Maybe you should consider altering the way in which you manage connections. Something like:\r\n\r\nOpen a connection at startup.\r\n\r\nOn `@app.before_request` verify that the connection wasn't closed by the database (or by any other reason). If it's closed, open it again, otherwise, recycle the connection.\r\n\r\nYou may be interested in a [pooled connection](http://docs.peewee-orm.com/en/latest/peewee/database.html?highlight=pooled#connection-pooling).\r\n\r\n## Edit\r\nThis is a bad advice, see @coleifer comment for clarification.", "Hi @NicolasCaous - thanks for those thoughts and link.\r\n\r\nI'll take your first suggestion. Do you know of the helper that checks if the connection is open? I am searching for it now.", "> Do you know of the helper that checks if the connection is open?\r\n\r\n[This one should do it.](http://docs.peewee-orm.com/en/latest/peewee/api.html#Database.is_closed)", "The reason for opening and closing connections has to do with thread-safety and being explicit. Most wsgi apps will use either threads or green-threads. Peewee's `Database` implementation, by default, stores connection state in a threadlocal. Opening a connection when the request starts is a good idea because it is explicit -- and it won't fail some arbitrary time later when the application actually tries to query the db. Closing a connection when the request is done is important so that you **release the resources** (which are associated with the thread that made the request). It is important to clean these up!\r\n\r\nNow, 0.5 seconds is a lot of overhead for establishing a db connection...I would suggest you have some serious issues in your network. But it should be on the order of milliseconds. See [this blog post](http://www.craigkerstiens.com/2014/05/22/on-connection-pooling/) for a bit of discussion.\r\n\r\nThat being said, you can avoid the setup cost by using a connection pool. Peewee provides these, and they use the same APIs as the regular non-pooled dbs, so you can drop it in.\r\n\r\nWhen using a connection pool with peewee it is **absolutely imperative** that you `close()` the connection when you're done using it (e.g., in the request teardown). Closing it releases the connection so it can be used again by a subsequent request. If you do not close it, your pool will grow and grow, which is bad.\r\n\r\nSo: follow the best practices. They are there for a reason.\r\n\r\nYou can mitigate the setup costs by using a connection pool, but you still need to call connect and close so the resources are recycled properly!\r\n\r\nLastly, 500ms is too much, I think you probably should investigate your network setup -- somethings very wrong there.", "Regarding @NicolasCaous comment,\r\n\r\n> On `@app.before_request` verify that the connection wasn't closed by the database (or by any other reason). If it's closed, open it again, otherwise, recycle the connection.\r\n\r\nUnless your WSGI server is single-threaded (ie no python threads, no green threads), this is bad advice.\r\n\r\nAs I said, Peewee stores connection state in a threadlocal. So if a greenlet is spawned to handle each request, it will have no visibility into the connection(s) being used by other greenlets, so it will always appear that the connection has not been opened.\r\n\r\nThe proper fix is to use a connection pool. http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#pool", "Hi @coleifer - thank you for your detailed comments!\r\n\r\nI will go for connection pooling - it's clear that it is the best solution here.\r\n\r\nRegarding the 500ms overhead, I'm not sure where this could originate from. I'm running a Flask server on Heroku on 2 standard-1x machines that are running 2 web processes and connecting to a Postgres server on Amazon RDS. It could be something to do with that.\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n", "I see that the standard connection parameters look something like this:\r\n\r\n```\r\ndb = PooledPostgresqlExtDatabase(\r\n 'my_app',\r\n max_connections=32,\r\n stale_timeout=300, # 5 minutes.\r\n user='postgres')\r\n```\r\n\r\nIs it possible to use a database connection string here?\r\n\r\nThanks!", "Yes, you can use a connection string to configure the pooled database connection.\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/playhouse.html#connect\r\n\r\nThe kwargs are parsed from the URL query parameters. \r\n", "Regarding heroku, are you using your own RDS database or the database provided by heroku?", "I'm using my own RDS database.", "Oh no...that's certainly the problem. You're connecting to your database over the public internet, which I don't think is ever a good idea. That introduces a lot of latency as every query has to go out across the internet. Typically you'll deploy your database in the same network as your application server, and you'll never expose it to the public internet." ]

[]

[]

[ "Yes you're right, I didn't think about partial indexes when designing the API. To fix this, I've added a new parameter, `conflict_where`, which should take the expression(s) that comprise the WHERE clause of the partial index.", "That was quick! Cheers", "@coleifer \r\nIs there a way to ignore duplicates that contains partial index with multiple conditions. \r\nPostgres Version: psql (10.17 (Ubuntu 10.17-1.pgdg20.04+1))\r\n\r\n**Partial Index** \r\n` \"participant_event_id_user_id_unique\" UNIQUE, btree (event_id, user_id) WHERE deleted = false AND event_id IS NOT NULL AND role <> 'test-admin'::text`.\r\n\r\n**Query**\r\n`insert into participant (role, user_id, created_by, event_id) VALUES ('proctor', 21937, 'com.talview.27585f36-4b68-4bbf-b41f-20a6c4a37d83', 2463) on conflict(user_id, event_id) where (\"role\" != 'test-admin') DO Nothing;`\r\n\r\n**Error**\r\nERROR: there is no unique or exclusion constraint matching the ON CONFLICT specification", "For it to match the partial index it must contain the same where clause conditions, as I understand it." ]

[]

[]

[ "That doesn't make any sense to me. Peewee doesn't automatically convert anything to ArrayField. People use their model classes with both SQLite and Postgres (ie Sqlite for tests, Postgres for production), and I've never heard of such an issue.\r\n\r\nIf you can provide instructions on how to reproduce this, I'll take a look. But you have not given me any information that I can use...other than you seem to be confused.", "ok faullt of my code excuse me \r\ni discover peewee and it's not very simple\r\n" ]