Strange, as there are many libraries for that already? https://github.com/timofurrer/awesome-asyncio#database-drivers

Strange, as there are many libraries for that already? https://github.com/timofurrer/awesome-asyncio#database-drivers

Real sync application can have many thousands simultaneous coroutines. If each coroutine open a separate connection to database and start long-lived transaction, it will not be too efficient IMO the correct approach is to have a separate database layer which accessed from async code through a queue. But it is hard to implement it in a generic way as a part of framework/library

SQLite has pretty rudimentary type support, and does not know anything about Decimal type. Because of this, in SQLite Pony stores values of Decimal type as strings, and convert them to Decimal when read them from the database. But it seems SQLite at this moment still convert such string values back to float, because it treats columns with DECIMAL type as columns with NUMERIC affinity (see 3.1 Determination of Column Affinity https://www.sqlite.org/datatype3.html) and for NUMERIC affinity, "when text data is inserted into a NUMERIC column, the storage class of the text is converted to INTEGER or REAL (in order of preference) if the text is a well-formed integer or real literal, respectively" It is a bit surprising to me that SQLite assigns NUMERIC affinity to DECIMAL column, I thought it was not this way when we implemented Decimal type support, but maybe I missed it from the beginning. So, in order to fix this bug we need to change the column type we use in SQLite for Decimal, in order to force a column to have TEXT or BLOB affinity. Looking at "3.1. Determination Of Column Affinity", we need to name type for Decimal columns something like DECIMALTEXT, to force storing decimal values in a textual form. This in itself is not enough to fix SUM function behavior. Standard SQLite SUM function will still convert values to REAL before summing them up. But it is possible to define custom aggregate function py_decimal_sum using create_aggregate https://docs.python.org/2/library/sqlite3.html#sqlite3.Connection.create_aggregate Then Pony can automatically call this function instead of standard SQLite SUM function when sum is perfomed on decimal column. This function will convert text values to decimal values on the fly, and then return result as a text value. It will perform slower then builtin SUM function. But anyway this is not a total solution, because if you do for example sum(decimal_column) * 2 then SQLite still convert decimal value to REAL, because it does not have support of decimal values and does not know how to do arithmetic operations with them

Currently it is not possible to unbind database (it may change with migration release). But you can create new db instance. One way to do it is defining entities inside a functions: def define_entities(db): class Foo(db.Entity): a = Required(int) class Bar(db.Entity): b = Optional(str) db = Database() define_entities(db) db.bind(**params) db.generate_mapping() with db_session: select(x for x in db.Foo) db2 = Database() define_entities(db2) db2.bind(**params2) ... The drawback is, IDE like Pycharm cannot understand what db.Foo is and which attributes it has

Hi folks! Just found this at https://github.com/ponyorm/pony/blob/orm-migrations/pony/orm/dbschema.py

Hello Alexander! As you may remember, I asked about the poor performance of bulk updates/inserts via Pony. I think I need to report that the Pony is perfect and that’s no problem there! 🙂 The reason was due to the large number of simultaneous threads that used the entire CPU core. I did some refactoring, and the scheduled tasks are now performed in the processes, so now the database performance is as fast as lightning 🙂