Datasets:

---

akumoth

/

peewee-issues

like 0

[]

[]

[ "I do not encounter any such error running peewee 2.10.1.\r\n\r\nCode:\r\n\r\n```python\r\nimport datetime\r\nfrom peewee import *\r\n\r\n\r\nclass Base(Model):\r\n class Meta:\r\n database = SqliteDatabase(':memory:')\r\n\r\n\r\nclass UpdateBatch(Base):\r\n timestamp = DateTimeField(default=datetime.datetime.now)\r\n batch_type = CharField(default='DEFAULT')\r\n\r\n class Meta:\r\n db_table = 'update_batches'\r\n primary_key = CompositeKey('timestamp', 'batch_type')\r\n\r\n\r\nBase._meta.database.create_tables([UpdateBatch])\r\n```", "Have you tried it with a MySQL backend? Looks like you're using Sqlite.", "No, I don't have MySQL handy at the moment. Can you try the above code with SQLite, however? I'd like to verify if this is a peewee issue or a peewee/mysql issue.", "Can do, please hold.", "Tried your code on both Sqlite and MySQL (fresh Docker container) and didn't encounter any issues. Will reexamine my code / test environment to see if I can find a difference.", "Looks like the issue is coming from my other classes in my model, which are using a `ForeignKeyField` to reference the `CompositeKey`. Looks like a duplicate of #270." ]

[]

[]

[]

[]

[]

[ "Try aliasing one of the columns, Book.id.alias('book_id') or Author.id.alias('author_id')." ]

[]

[]

[ "You're going the \"wrong way\" when following that query. You'll need to use `prefetch()` instead.\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/querying.html#list-users-and-all-their-tweets\r\n\r\nI'd suggest giving the docs on N+1 a close read. The approach you're using works fine for getting an object and a singular related instance (i.e., would work fine for listing all members and a given group). But when you have a single instance and want to get all objects that are related to it, you need to use `prefetch()`." ]

[]

[]

[ "Found the problem which was in peewee_migrate. So nothing to see here. More information for curious: https://github.com/klen/peewee_migrate/issues/51" ]

[]

[]

[ "It appears to be working as I'd expect. In the example below the database is reporting a table named \"Foo\" and the SELECT query is querying the \"Foo\" table (successfully).\r\n\r\n```python\r\nIn [1]: from peewee import *\r\n\r\nIn [2]: db = SqliteDatabase('/tmp/foo.db')\r\n\r\nIn [3]: class Foo(Model):\r\n ...: value = TextField()\r\n ...: class Meta:\r\n ...: db_table = 'Foo'\r\n ...: database = db\r\n ...: \r\n\r\nIn [4]: db.create_tables([Foo])\r\n\r\nIn [5]: db.get_tables()\r\nOut[5]: [u'Foo']\r\n\r\nIn [6]: Foo.create(value='x')\r\nOut[6]: <__main__.Foo at 0x7fdd08157ed0>\r\n\r\nIn [7]: Foo.select()\r\nOut[7]: <class '__main__.Foo'> SELECT \"t1\".\"id\", \"t1\".\"value\" FROM \"Foo\" AS t1 []\r\n\r\nIn [8]: Foo.get()\r\nOut[8]: <__main__.Foo at 0x7fdd0815eb10>\r\n\r\n```", "Hi Charles, \r\nI found the issue after trying the deployment on a Linux machine. \r\nMySQL on Windows makes DB table names lowercase by default (for some reason).\r\nYou have to manually change that option in the ini-file.\r\n\r\nSorry for the trouble!\r\n\r\nCheers,\r\nTim" ]

[]

[]

[ "It works fine for me:\r\n\r\n```python\r\nIn [1]: from peewee import *\r\n\r\nIn [2]: db = PostgresqlDatabase('peewee_test')\r\n\r\nIn [3]: db.execute_sql('select %s', ('asd',)).fetchone()\r\nOut[3]: ('asd',)\r\n```", "@coleifer select is ok, but it's just a example. Table aaa is not exists so exception raised.\r\nI just want to say quote seems wrong, and some statements were influenced.", "More realistic example:\r\n```python\r\n# You know column or table name starts with digit is valid on PostgreSQL\r\n# I guess that's a reason of db.quote_char design\r\n# SQL: create table \"123\"(\"456\" int);\r\n\r\ndb.execute_sql('select * from \"123\"')\r\n# OK\r\ndb.execute_sql('select * from %s', (\"123\",))\r\n# peewee.ProgrammingError: syntax error at or near \"'123'\"\r\n# LINE 1: select * from '123'\r\n\r\ndb.execute_sql('insert into %s (%s) values (1)', (\"123\", \"456\"))\r\n# peewee.ProgrammingError: syntax error at or near \"'123'\"\r\n# LINE 1: insert into '123' ('456') values (1)\r\n```\r\n\r\nIf design table by myself, I will never use these bad names.\r\nActually I'm trying to convert csv to postgreSQL table, so I should use origin names.\r\n", "@fy0 -- Postgres quotes things using single quotes to express string literals. The quote_char is used to identify named entities, not for indicating string literals or doing some kind of escaping.", "@coleifer ' for string literals, \" for identify named entities (columns, tables), right? \r\nNow table's name is 123, column's name is 456, and peewee's execute_sql crashed. \r\nI'm not sure I'm completely understand about how quote_char works, the crash is actually happened, others are my guess. \r\n\r\nsome snippets from peewee:\r\n```python\r\nclass QueryCompiler(object):\r\n def quote(self, s):\r\n return '%s%s%s' % (self.quote_char, s, self.quote_char)\r\n\r\nclass Database(object):\r\n compiler_class = QueryCompiler\r\n quote_char = '\"'\r\n\r\n def compiler(self):\r\n return self.compiler_class(\r\n self.quote_char, self.interpolation, self.field_overrides,\r\n self.op_overrides)\r\n\r\n def execute(self, clause):\r\n return self.execute_sql(*self.compiler().parse_node(clause))\r\n\r\n def execute_sql(self, sql, params=None, require_commit=True):\r\n logger.debug((sql, params))\r\n with self.exception_wrapper:\r\n cursor = self.get_cursor()\r\n try:\r\n cursor.execute(sql, params or ())\r\n except Exception:\r\n if self.autorollback and self.get_autocommit():\r\n self.rollback()\r\n raise\r\n else:\r\n if require_commit and self.get_autocommit():\r\n self.commit()\r\n return cursor\r\n\r\n\r\nclass PostgresqlDatabase(Database):\r\n pass # inherited\r\n\r\n\r\nclass MySQLDatabase(Database):\r\n quote_char = '`'\r\n```\r\n\r\nemmmm, maybe it's doesn't matter about quote_char because compiler not work?\r\n\r\n```python\r\ndb.execute(peewee.SQL('insert into %s (%s) values (1)', \"123\", \"456\"))\r\n# peewee.ProgrammingError: syntax error at or near \"'123'\"\r\n# LINE 1: insert into '123' ('456') values (1)\r\n```\r\n\r\nSomething went wrong, but it's too hard to find and solve it to me. \r\nFix it please. peewee is one of my favorite package of python, thanks for your hard works.\r\nGoing to bed, see you tomorrow.\r\n", "I think you're mixing up quoting and escaping. They are two completely different things. In your last example (the INSERT INTO %s (%s) VALUES (1)) -- you are doing literally the exact opposite of what you should do. The table name and column name should be quoted literals -- not parameterized, while the actual value being inserted *should* be parameterized.\r\n\r\nWhat you want would be:\r\n\r\n 'INSERT INTO \"123\" (\"456\") VALUES (%s)', (1,)\r\n\r\nAs you can see, quote_char is a double quote, and it is used to wrap the named entities in the query -- the table and column. The \"%s\" is used to parameterize a query -- safely include values without risking SQL injection -- so we use the %s instead of the `1`.", "@coleifer You mean there is no method to escape table and column names for raw sql execute .... %s is only for values, right?\r\n\r\nTested. Example of injection:\r\n```python\r\nclass NewModel(peewee.Model):\r\n class Meta:\r\n database = db\r\n db_table = '1\"23'\r\n\r\nq = NewModel.select()\r\nprint(q)\r\n# <class '__main__.NewModel'> SELECT \"t1\".\"id\" FROM \"1\"23\" AS t1 []\r\n```\r\n\r\n```python\r\nclass NewModel(peewee.Model):\r\n class Meta:\r\n database = db\r\n db_table = 'asd\" as t1; drop table \"123\" --'\r\n\r\nq = NewModel.select()\r\nprint(q)\r\nq.execute()\r\n\r\n# <class '__main__.NewModel'> SELECT \"t1\".\"id\" FROM \"asd\" as t1; drop table \"123\" --\" AS t1 []\r\n\r\n# asd is another table\r\n# now table '123' dropped\r\n```\r\n\r\nIf admin interface provide a table design page, attackers can easily do everything they want by post evil names. I always thought names are escaped by default, It's so dangerous ...\r\n", "@fy0 -- yes, `%s` is just for values, and double quotes are to wrap things like table or column names.\r\n\r\nIf you're using Peewee, you'll typically declare your table and columns as Python Model classes. I don't see any risk for SQL Injection unless you were doing something like prompting the user to supply you with the table and column names to execute queries on... which seems ridiculous.\r\n\r\nAs a dev, you control the table and col names. Shouldn't be an issue.", "@coleifer Developers not always have 100% control. Such as model design tool, import data, peewee's pwiz and csv tools.\r\n\r\nOn the other hand, different database usually beaver difference with name quote sign. ORM's work is eliminate difference between databases. It's my advice.", "Peewee *does* eliminate the differences in parameterizing queries...you don't have to think about the fact that sqlite uses \"?\" and mysql/pg use \"%s\". Peewee also prevents you from having to think about quoting, because peewee automatically quotes tables and columns for you using the db-specific character.\r\n\r\nI'm not even sure what you're asking for at this point.", "@coleifer I have the similar issue. \r\n```\r\nclass Base(playhouse.signals.Model):\r\n class Meta:\r\n database = db\r\n\r\n def partial_update(self, partial_data):\r\n SQL = \"update %s set data = data || %s where tid = %s\"\r\n vals = (self._meta.db_table, partial_data, self.tid)\r\n db_pointer.execute_sql(SQL, vals)\r\n\r\nclass Table1(Base):\r\n class Meta:\r\n db_table = 'table1'\r\n\r\nclass Table2(Base):\r\n class Meta:\r\n db_table = 'table2'\r\n```\r\nSo partial_update function can be called on any of the Table. For that, I need to use %s and the respective table name to update.\r\n\r\nThe error I received is:\r\n```\r\nFile \"/home/stark/.local/lib/python2.7/site-packages/playhouse/postgres_ext.py\", line 383, in execute_sql\r\n cursor.execute(sql, params or ())\r\nProgrammingError: syntax error at or near \" ' table1 ' \"\r\nLINE 1: update 'table1' set data = data || '{\"status\": ...`\r\n```\r\n\r\nWhat should I do in this case?\r\n\r\nPS: If I write the name of the table directly without using %s, then it works fine.", "Why are you using an ORM like Peewee if you are writing simple update queries using plain sql?\r\n\r\n```python\r\n\r\ndef partial_update(self, partial_data):\r\n model = type(self) \r\n query = model.update({model.data: model.data.concat(partial_data)}).where(model.tid == self.tid)\r\n return query.execute()\r\n```\r\n\r\nAs for mixing string interpolation and query parameterization, I strongly suggest that you don't do it that way...it's so clumsy. If you must, you should do this:\r\n\r\n```python\r\nquery = \"update %s set data = %%s\" % table_name\r\ndb.execute_sql(query, params)\r\n```\r\n\r\nAlso db_pointer?? This is python bro.", "@coleifer Could not find how to update jsonb field without getting the data that's why used plain SQL.\r\nI asked on StackOverflow but didn't get an answer. ([post)](https://stackoverflow.com/questions/48290053/how-to-update-jsonb-field-in-postgres-v9-4-using-peewee)\r\n\r\nRunning the update function you suggested, gave me the following error.\r\n```\r\nFile \"/home/stark/.local/lib/python2.7/site-packages/playhouse/postgres_ext.py\", line 383, in execute_sql\r\n cursor.execute(sql, params or ())\r\nDataError: invalid concatenation of jsonb objects\r\n```\r\nI have used `json.dumps(partial_data)` to send as string. Any suggestions.?", "@pranjalsingi -- did you try not converting it to a string?", "@coleifer It worked. I passed partial_data as a dictionary. \r\nThank you, soo much." ]

[]

[]

[ "It seems to be working OK for me:\r\n\r\n```python\r\nfrom peewee import *\r\n\r\nclass ListField(Field):\r\n def db_value(self, value):\r\n return ','.join(value)\r\n def python_value(self, value):\r\n return value.split(',')\r\n\r\ndb = SqliteDatabase(':memory:')\r\n\r\nclass Register(Model):\r\n data = TextField()\r\n items = ListField()\r\n class Meta:\r\n database = db\r\n\r\ndb.create_tables([Register])\r\n\r\nr = Register.create(data='foo,bar,baz', items=['foo', 'bar', 'baz'])\r\nr.items # ['foo', 'bar', 'baz']\r\n\r\nr_db = Register.get()\r\nr_db.items # ['foo', 'bar', 'baz']\r\n```", "Ok, so I think I narrowed it down to the get_or_create method. \r\n\r\nr, c = Register.get_or_create(data='foo,bar,baz', items=['foo', 'bar', 'baz'])\r\n\r\nUse that to recreate", "When doing a `SELECT`, peewee doesn't know if the list you are passing should be unpacked (as it would for an `IN` query, for example). To work around, when passing lists in this situation you should wrap it in Param:\r\n\r\n```python\r\nr = Register.select().where(Register.items == Param(['foo', 'bar', 'baz']))\r\n```", "In Peewee 3.0a, you can accomplish the same `AsIs`.", "Problem solved :) Thank you for the quick help!" ]

[]

[]

[ "Replaced with a similar patch. Thnx." ]

[]

[]

[ "I figured this out after some digging in the code. See my PR for a small change to the docs. ", "It would be nice if there was a way to change the db handle on an application wide basis. The Using context manager loses scope when calling outside functions. \r\n\r\nI will take a stab at trying to implement this. Any advice on how to do it? ", "> It would be nice if there was a way to change the db handle on an application wide basis.\r\n\r\nYou can always implement an abstraction layer that handles this kind of thing. Or use the `Proxy` object:\r\n\r\n```python\r\ndb = Proxy()\r\ndb_1 = SqliteDatabase('one.db')\r\ndb_2 = SqliteDatabase('two.db')\r\n\r\nclass MyModel(Model):\r\n class Meta:\r\n database = db\r\n\r\nclass AnotherModel(Model):\r\n class Meta:\r\n database = db\r\n\r\ndb.initialize(db_1) # Now MyModel and AnotherModel are using db_1\r\n\r\n# do some stuff....\r\n\r\ndb.initialize(db_2) # Now they're using db_2...\r\n```" ]

[]

[]

[]

[]

[]

[ "Implementing `INSERT/IGNORE` for all databases should be straightforward.\r\n\r\nFor SQLite and for MySQL, in the simple case of a `REPLACE` query, the semantics are the same just slightly different SQL syntax.\r\n\r\nFor MySQL and Postgresql, in the not-so-simple case, it seems like the following things will need to be in-place in Peewee's APIs:\r\n\r\n* Referencing the values that would have been inserted (`VALUES(x)` in MySQL, `EXCLUDED.x` in Postgres).\r\n* Referencing the pre-existing value of a column in the event of an update.\r\n* Specify which columns / constraint the conflict applies to (Postgres only).", "In MySQL, Replace will delete the conflict row and insert a new row, but on duplicate key update just update the old row. So if the only constraint on the table was on column a, they are still different.", "@hzweveryday -- thank you for letting me know of that distinction, that's quite important!", "Roughing out some APIs / implementation: 500910da7f358c62b42ddd968b78f0352d7f49b3", "Implemented for SQLite, MySQL and Postgres: 8de7d16f022a92daae2d8c0b9ea798b375e09bff\r\n\r\nHere are some examples (I'm open to suggestions on the API):\r\n\r\n```python\r\n# Stupid simple example.\r\nPerson.insert(name='huey').on_conflict('ignore')\r\n\r\n# Generates:\r\n# sqlite: INSERT OR IGNORE INTO \"person\" (\"name\") VALUES ('huey')\r\n# mysql: INSERT IGNORE INTO \"person\" (\"name\") VALUES ('huey')\r\n# postgres: INSERT INTO \"person\" (\"name\") VALUES ('huey') ON CONFLICT DO NOTHING\r\n\r\n# Slightly more interesting.\r\n(Person\r\n .insert({Person.name: 'huey', Person.dob: some_date})\r\n .on_conflict(\r\n preserve=(Person.dob,),\r\n update={Person.name: Person.name.concat(' (updated)')}))\r\n\r\n# Generates:\r\n# sqlite: not supported\r\n# mysql: INSERT INTO \"person\" (\"name\", \"dob\") VALUES ('huey', ...) \r\n# ON DUPLICATE KEY UPDATE \"dob\" = VALUES(\"dob\"), \"name\" = \"name\" || ' (updated)'\r\n# postgres: requires a conflict target, see next example\r\n\r\n(Person\r\n .insert(name='huey', dob=some_date)\r\n .on_conflict(\r\n conflict_target=(Person.name,),\r\n preserve=(Person.dob,),\r\n update={Person.name: Person.name.concat(' (updated)')))\r\n\r\n# postgres: INSERT INTO \"person\" (\"name\", \"dob\") VALUES ('huey', ...) \r\n# ON CONFLICT (\"name\")\r\n# DO UPDATE SET \"dob\" = EXCLUDED.\"dob\", \"name\" = \"name\" || ' (updated)'\r\n```", "sqlite's `INSERT OR REPLACE` is not analogous to `UPSERT`. If you have a table with 4 fields -- 3 come from the outside and the 4th comes from elsewhere -- then `INSERT OR REPLACE` on that record loses the existing value in the 4th column.", "For MySQL I've found that `REPLACE INTO` is hardly ever the right thing to do. So the preference would be to use `INSERT INTO ... ON DUPLICATE KEY`.\r\n\r\nThat also allows you to basically do a mass update of the table with only partial fields.\r\n\r\nTake a table with fields: id, a, b, c, d, e\r\nYou could do\r\n```sql\r\nINSERT INTO table (id, c) VALUES\r\n (1, 'something'),\r\n (2, 'somethingelse')\r\nON DUPLICATE KEY UPDATE\r\n c=VALUES(c)\r\n```\r\nand not lose the values in a, b, d, e (provided that each id already existed).\r\n\r\n(And yes, I just leveraged that for a real life case with the exception being I used an `INSERT INTO ... SELECT ... ON DUPLICATE KEY UPDATE` instead of suppling the values manually)", "The upsert API for MySQL supports both REPLACE and ON DUPLICATE KEY.", "The postgres example does not seem to work: \r\n\r\n`TypeError: on_conflict() got an unexpected keyword argument 'conflict_target'`", "Postgres example from tests:\r\n\r\n```python\r\nclass Emp(TestModel):\r\n first = CharField()\r\n last = CharField()\r\n empno = CharField(unique=True)\r\n\r\n class Meta:\r\n indexes = (\r\n (('first', 'last'), True),\r\n )\r\n\r\ntest_data = (\r\n ('huey', 'cat', '123'),\r\n ('zaizee', 'cat', '124'),\r\n ('mickey', 'dog', '125'),\r\n )\r\n\r\nfor first, last, empno in self.test_data:\r\n Emp.create(first=first, last=last, empno=empno)\r\n\r\n def test_update(self):\r\n res = (Emp\r\n .insert(first='foo', last='bar', empno='125')\r\n .on_conflict(\r\n conflict_target=(Emp.empno,),\r\n preserve=(Emp.first, Emp.last),\r\n update={Emp.empno: '125.1'})\r\n .execute())\r\n self.assertData([\r\n ('huey', 'cat', '123'),\r\n ('zaizee', 'cat', '124'),\r\n ('foo', 'bar', '125.1')])\r\n\r\n res = (Emp\r\n .insert(first='foo', last='bar', empno='126')\r\n .on_conflict(\r\n conflict_target=(Emp.first, Emp.last),\r\n preserve=(Emp.first,),\r\n update={Emp.last: 'baze'})\r\n .execute())\r\n self.assertData([\r\n ('huey', 'cat', '123'),\r\n ('zaizee', 'cat', '124'),\r\n ('foo', 'baze', '125.1')])\r\n```", "Hey @coleifer, long time no speak :) Just ran into an issue with this, I'm trying to use `bulk_insert()` and would like it to ignore any duplicate entries. This was also raised in https://github.com/coleifer/peewee/issues/1067 . Tried using `on_conflict()` but didn't seem to do anything when using `bulk_insert()`. Any ideas?\r\n\r\nEDIT: Ahh never mind, it was a bug on my own code, `on_conflict('IGNORE')` seems to work beautifully!", "Oh hell yeah I'm glad to hear! I've been using it myself but only with sqlite. Good to hear from you @foxx", "This project is so amazing! @coleifer Just wanted to say that you're amazing. One the best API designs I've seen. Thanks", "Glad you're enjoying the project!", "Any advice on how to get this to work with bulk operations? I'm trying to get it to function with bulk_insert_mappings. on_conflict('ignore') doesn't seem to have any effect.\r\n```\r\nsession.bulk_insert_mappings(\r\n Event,\r\n event_list\r\n ).on_conflict('ignore')\r\n```", "Session and bulk insert mapping are not peewee apis.", "Peewee would use:\r\n\r\n```python\r\nEvent.insert_many(event_list).on_conflict('ignore')\r\n```\r\n\r\nAssuming event_list was a list of dictionaries." ]

[]

[]

[ "You don't have the SQLite FTS4 extension. You'll need to either compile it as a standalone and load it at run-time, or recompile SQLite with full-text search feature enabled. https://sqlite.org/fts3.html", "Hello, I am using Anaconda with Python 3.7, how can I install FTS4 extension?", "I'd suggest asking anaconda." ]

[]

[]

[ "duplicate of #1067" ]

[]

[]

[ "Added here: 13c15c3a8e086939184c3b885f3dbb4d057b68a5\r\n\r\nThis functionality is provided in the 3.0 branch (not yet public) as well." ]

[]

[]

[ "0137c5eb12172b1c127239f58ccbc98fbbbda982" ]

[]

[]

[ "I definitely understand your confusion, and likely the docs aren't clear on this point.\r\n\r\nInside `ForeignKeyField.add_to_class()` you can see that the \"id descriptor\" gets its attribute from the db_column (if set) and otherwise will be the field's name + \"_id\":\r\n\r\n```python\r\n self.db_column = obj_id_name = self.db_column or '%s_id' % self.name\r\n if obj_id_name == self.name:\r\n obj_id_name += '_id'\r\n```\r\n\r\nSo what you're seeing is correct according to the above logic.", "Yeah, I eventually found that. I guess I just felt that if you're \"renaming\" a foreign key field, then both the name-descriptor and id-descriptor values would change accordingly. My goal in the example was to entirely replace the usage of place/place_id with venue/venue_id (without having to rename the actual database column). When I'm thinking about the venue FK, I want to hide/abstract-away the fact that under the hood it's actually referencing the `place_id` column.\r\n", "I don't want to break backwards compatibility in case anyone was relying on the behavior described in your issue, *however* I've added a new parameter to `ForeignKeyField` that allows you to specify the name of the \"object id descriptor\". Your declaration would read:\r\n\r\n```python\r\nvenue = ForeignKeyField(Venue, db_column='place_id', object_id_name='venue_id')\r\n```", "Awesome. That's a good solution. Thanks!" ]

[]

[]

[ "Um...are you referencing `ArrayField` somewhere in your module? `ArrayField` is defined in `playhouse.postgres_ext` so to use it you'll need to import it along with `PostgresqlExtDatabase`.", "after that, I import ArrayField with:\r\nfrom playhouse.postgres_ext import ArrayField\r\n\r\nthat say:\"peewee.ProgrammingError: hstore type not found in the database. please install it from your 'contrib/hstore.sql' file\"\r\n\r\nthanks\r\n", "other wise:\r\nI did not use 'hstore'", "That is ok， NOW！！\r\n\r\ni forgot add hstore extension\r\nuse ‘ create extension hstore’\r\n" ]

[]

[]

[ "To customize the table name on a one-off basis, you set the `db_table` option on the model's inner `Meta` class.\r\n\r\nTo set the table name dynamically, you can actually specify a different `Meta` attribute `db_table_func`. This should be a callable that receives the newly-created `Model` class, and returns a string to use as the table name.\r\n\r\nI think this should probably accomplish what you want." ]

[]

[]

[ "I'm not quite following...if you're just looking to store text (encoded as UTF-8), the proper field to use is the `TextField`.\r\n\r\nCan you try modifying your code to use `TextField` instead of `BlobField` and see if that resolves the issue?", "Yes TextField works indeed. I think pwiz generated it as BlobField. I thought it was right since it can be huge. I am not sure now if the behaviour when it's BlobField is correct though.\r\n", "Glad it's working." ]

[]

[]

[ "No, type hints are, in my opinion, an abomination that has no business being part of the Python language :)", "May I at least add peewee's .pyi stubs to python/typeshed repository? ", "Anything you would like to do is totally fine by me, as the license for the software is permissive. I just do not want to merge anything into mainline that concerns type hinting.", "@coleifer I'm expecting you will make a deal with static typing fans more and more. I'm partially agree you can do nothing in orm itself and should not, but you should try to understand `static dynamic` fans. Its not about limiting dynamism or to make new java from python, people just want `user.(name/id/group)` in IDE, they are tired to go from view to model definition, to 'google' any functions signature, to debug typo mistakes in runtime. \r\n\r\nGo has no objects and generics, and any data structure should upcast value to `interface{}`, C is just too low-level. You should check out [typeorm](http://typeorm.io/) and [diesel](http://diesel.rs/), Dart. \r\nStatic typing was stigmatized long time as a way to make compilable, fast languages like java, cpp. It has different purpose in dynamic languages now.", "> I'm expecting you will make a deal with static typing fans more and more.\r\n\r\nNo way. Python is a powerful dynamic language. If I want static typing or a strong type system I will use C or go...or hell, Cython. I enjoy coding in those languages, too, but if I'm using Python I'm going to play to it's strengths.\r\n\r\n> IDE\r\n\r\nPeewee's design goals are composability and consistency -- learn once, apply everywhere -- precisely so that peewee will \"do what you expect\" without needing to check the docs.", "@coleifer I'm not a strong proponent of Static Typing, but the type annotations are extremely useful when developing to help catch bugs. I debug enough Python at runtime, the more I can do to reduce that, the better.\r\n\r\nMypy is optional, you can choose to put annotations on things, for clarity. If the inclusion of these things only ever produces net gain, why not apply them. It's not an either-or camp. The degree to which you add Static Types is varying.\r\n\r\nSurely you can see the point of view of why Type annotations may be extremely useful? And in no ways detracts from the power and flexibility of Python by its inclusion.\r\n", "Sorry to necro this thread but in my experience I've also noticed that type hints can also add a significant performance boost (sometimes >20%) since Cython can now use them for type inference. Granted, performance benefits aren't _guaranteed_ but they are likely. I see you have Cython support set up for PeeWee so it's entirely possible its performance could benefit from it.", "Hi @coleifer,\r\n\r\nYou've done a great job with this lib. With or without type hints, it's nice to use.\r\n\r\nBut if someday you change your mind about type hints, I believe it won't hurt.", "> No, type hints are, in my opinion, an abomination that has no business being part of the Python language :)\r\n\r\nAs a maintainer of typeshed, a big repository that is all about typing in Python, I think this is a perfectly valid opinion! I felt the same when I first learned about typing in Python. It shouldn't be something that library authors have to do, and it's optional by design.", "This issue was opened nearly 5 years ago. In that time I've had plenty of opportunities to see python's type hinting in the wild. I still believe that it misses the mark, offerning none of the iron-clad guarantees you get from a statically-typed language, while being injurious to Python's inherent dynamism, readability, and simplicity. Since this issue tends to attract drive-by comments of little value, I'm going to close discussion for now.\r\n\r\nWhen I want static typing I reach for a statically-typed language. When I want expressiveness, simplicity and flexibility, I reach for Python." ]

[]

[]

[ "Ahh yeah, the code is probably a bit out-dated and does not reflect what I've since learned about some best practices for the full-text search extension. Let me see about updating things.", "Ahh shit, I see I already left a note on code compatibility at the top of the post. I'm going to leave this alone for now, as I don't have time to go back through the code to update it all. Apologies for leaving you hanging -- I'll try to post an update, and when I do I'll update this ticket.", "Ah I should read more carefully. I will use a older version for now. Thanks!" ]

[]

[]

[ "If you're trying to pass arguments into the pymysql constructor, just pass them in as keyword arguments to the `MySQLDatabase` initialization method. They'll get passed back to the database driver.", "e.g. `MySQLDatabase(..., threadsafety=1)`", "@coleifer \r\n\r\nGot exception:\r\n\r\n```\r\nFile \"/anaconda3/anaconda/lib/python3.5/site-packages/peewee.py\", line 3708, in _create_connection\r\n return self._connect(self.database, **self.connect_kwargs)\r\n File \"/anaconda3/anaconda/lib/python3.5/site-packages/peewee.py\", line 4256, in _connect\r\n return mysql.connect(db=database, **conn_kwargs)\r\n File \"/anaconda3/anaconda/lib/python3.5/site-packages/pymysql/__init__.py\", line 90, in Connect\r\n return Connection(*args, **kwargs)\r\nTypeError: __init__() got an unexpected keyword argument 'threadsafety'\r\n```\r\n\r\nThis is how I did:\r\n\r\n```\r\ndbhandle = MySQLDatabase(\r\n db_name, user=user,\r\n password=password,\r\n host=host,\r\n threadsafety=3\r\n)\r\n```", "I have no idea then, but whatever the case, the issue is not with Peewee.", "@kadnan 您好,我也遇到了这样的问题,请问您是怎么解决的呢？" ]

[]

[]

[ "Sorry, no plans to support that.", "Is this supported now?" ]

[]

[]

[ "ffs man documentation\r\n\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#SelectQuery.exists\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#SelectQuery.count", "I was searching for the same thing (I don't usually RTFM right away either). Just to let you know that your links don't take you to the right place on the page as I assume the # is supposed to do.", "* http://docs.peewee-orm.com/en/latest/peewee/api.html#SelectBase.exists\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#SelectBase.count\r\n\r\ntl/dr\r\n\r\n```python\r\n\r\nquery = User.select().where(User.username == 'reads-the-manual')\r\nif query.exists():\r\n print('there are %s users who %s' (query.count(), 'read the manual'))\r\n```", "Funny thing is that I had to google something similar after 4 years and I found my own opened issue 😆 ", "Hell yeah. I've had that happen once or twice myself." ]

[]

[]

[ "You're working with an instance but the `get()` method is a class-method. So:\r\n\r\n```python\r\nwith database.transaction():\r\n TestDB.create(k='key1', v='value1')\r\ntdb = TestDB.get(TestDB.k == 'key1')\r\n```" ]

[]

[]

[ "Yeah actually that looks good! You can verify by turning query logging on:\r\n\r\n```python\r\nimport logging\r\nlogger = logging.getLogger('peewee')\r\nlogger.addHandler(logging.StreamHandler())\r\nlogger.setLevel(logging.DEBUG)\r\n```", "I got the query log as the way you told me, and the log are as below\r\n__Note: This happened when I fetch both contract.customer.name and contract.salesman.name . And just the first query executed if I only fetch the contract.customer.name .__\r\n\r\n```sql\r\n--------------------------------------------------------------------------------\r\n('SELECT `t1`.`id`, `t1`.`contract_no`, `t1`.`customer_id`, `t1`.`salesman_id`, `t1`.`total_price`, `t1`.`is_internal`, `t1`.`company`, `t1`.`project`, `t1`.`sign_time`, `t1`.`effective_time`, `t1`.`expired_time`, `t1`.`notes`, `t1`.`timestamp`, `t2`.`username`, `t2`.`mphone`, `t3`.`username` FROM `t_contract` AS t1 INNER JOIN `t_user` AS t2 ON (`t1`.`customer_id` = `t2`.`id`) LEFT OUTER JOIN `t_user` AS t3 ON (`t1`.`salesman_id` = `t3`.`id`) WHERE (`t1`.`customer_id` = %s)', [u'1'])\r\n('SELECT `t1`.`id`, `t1`.`username`, `t1`.`role_id`, `t1`.`email`, `t1`.`mphone`, `t1`.`is_disable`, `t1`.`is_admin`, `t1`.`is_enterprise`, `t1`.`credits`, `t1`.`created_time`, `t1`.`updated_time` FROM `t_user` AS t1 WHERE (`t1`.`id` = %s) LIMIT 1', [u'345'])\r\n('SELECT `t1`.`id`, `t1`.`username`, `t1`.`role_id`, `t1`.`email`, `t1`.`mphone`, `t1`.`is_disable`, `t1`.`is_admin`, `t1`.`is_enterprise`, `t1`.`credits`, `t1`.`created_time`, `t1`.`updated_time` FROM `t_user` AS t1 WHERE (`t1`.`id` = %s) LIMIT 1', [u'346'])\r\n('SELECT `t1`.`id`, `t1`.`username`, `t1`.`role_id`, `t1`.`email`, `t1`.`mphone`, `t1`.`is_disable`, `t1`.`is_admin`, `t1`.`is_enterprise`, `t1`.`credits`, `t1`.`created_time`, `t1`.`updated_time` FROM `t_user` AS t1 WHERE (`t1`.`id` = %s) LIMIT 1', [u'345'])\r\n('SELECT `t1`.`id`, `t1`.`username`, `t1`.`role_id`, `t1`.`email`, `t1`.`mphone`, `t1`.`is_disable`, `t1`.`is_admin`, `t1`.`is_enterprise`, `t1`.`credits`, `t1`.`created_time`, `t1`.`updated_time` FROM `t_user` AS t1 WHERE (`t1`.`id` = %s) LIMIT 1', [u'345'])\r\n('SELECT `t1`.`id`, `t1`.`username`, `t1`.`role_id`, `t1`.`email`, `t1`.`mphone`, `t1`.`is_disable`, `t1`.`is_admin`, `t1`.`is_enterprise`, `t1`.`credits`, `t1`.`created_time`, `t1`.`updated_time` FROM `t_user` AS t1 WHERE (`t1`.`id` = %s) LIMIT 1', [u'345'])\r\n('SELECT `t1`.`id`, `t1`.`username`, `t1`.`role_id`, `t1`.`email`, `t1`.`mphone`, `t1`.`is_disable`, `t1`.`is_admin`, `t1`.`is_enterprise`, `t1`.`credits`, `t1`.`created_time`, `t1`.`updated_time` FROM `t_user` AS t1 WHERE (`t1`.`id` = %s) LIMIT 1', [u'345'])\r\n('SELECT `t1`.`id`, `t1`.`username`, `t1`.`role_id`, `t1`.`email`, `t1`.`mphone`, `t1`.`is_disable`, `t1`.`is_admin`, `t1`.`is_enterprise`, `t1`.`credits`, `t1`.`created_time`, `t1`.`updated_time` FROM `t_user` AS t1 WHERE (`t1`.`id` = %s) LIMIT 1', [u'345'])\r\n('SELECT `t1`.`id`, `t1`.`username`, `t1`.`role_id`, `t1`.`email`, `t1`.`mphone`, `t1`.`is_disable`, `t1`.`is_admin`, `t1`.`is_enterprise`, `t1`.`credits`, `t1`.`created_time`, `t1`.`updated_time` FROM `t_user` AS t1 WHERE (`t1`.`id` = %s) LIMIT 1', [u'345'])\r\n('SELECT `t1`.`id`, `t1`.`username`, `t1`.`role_id`, `t1`.`email`, `t1`.`mphone`, `t1`.`is_disable`, `t1`.`is_admin`, `t1`.`is_enterprise`, `t1`.`credits`, `t1`.`created_time`, `t1`.`updated_time` FROM `t_user` AS t1 WHERE (`t1`.`id` = %s) LIMIT 1', [u'345'])\r\n('SELECT `t1`.`id`, `t1`.`username`, `t1`.`role_id`, `t1`.`email`, `t1`.`mphone`, `t1`.`is_disable`, `t1`.`is_admin`, `t1`.`is_enterprise`, `t1`.`credits`, `t1`.`created_time`, `t1`.`updated_time` FROM `t_user` AS t1 WHERE (`t1`.`id` = %s) LIMIT 1', [u'345'])\r\n```\r\n\r\nI got N+1 queries", "Finally I resolved this problem by Calling the SelectQuery instance's method `dicts()`.\r\n\r\n``` python\r\n Customer = User.alias()\r\n Salesman = User.alias()\r\n\r\n contracts = (Contract\r\n .select(Contract.id,\r\n Contract.contract_no,\r\n Contract.total_price,\r\n Contract.company,\r\n Contract.project,\r\n Contract.sign_time,\r\n Contract.is_internal,\r\n Customer.mphone,\r\n Customer.name.alias('customer_name'),\r\n Salesman.name.alias('salesman_name')\r\n )\r\n .join(Customer, on=(Contract.customer == Customer.id))\r\n .join(Salesman, JOIN.LEFT_OUTER, on=(Contract.salesman == Salesman.id))\r\n .where(Contract.customer == user_id)\r\n )\r\n for contract in contracts.dicts():\r\n contract.get('salesman_name')\r\n contract.get('customer_name')\r\n```\r\n\r\nIs there a cool way ?", "Ahh shit I missed something in your initial query. In order to access related models, you will need to assign an alias to the join predicate. Additionally, after joining on Customer you need to switch the join context back to Contract so that when you join on Salesman peewee knows how to reconstruct the model graph. This code works as expected:\r\n\r\n```python\r\ncontracts = (Contract\r\n .select(Contract, Customer.name, Salesman.name)\r\n .join(Customer,\r\n on=(Contract.customer == Customer.id).alias('customer'))\r\n .switch(Contract)\r\n .join(Salesman,\r\n on=(Contract.salesman == Salesman.id).alias('salesman'))\r\n .order_by(Contract.contract_no))\r\nfor contract in contracts:\r\n print contract.contract_no, contract.customer.name, contract.salesman.name\r\n```" ]

[]

[]

[ "This type of question is more appropriate to stackoverflow.\r\n\r\nHowever...when you create a query, you necessarily know what columns are being selected. So how can there be a problem?", "Because you may want to write your code in such a way that it can be reused without passing the names of columns explicitly, especially because this information is already part of the results object.\r\n\r\nIt appears that you get a different API depending on whether speedups are enabled. With speedups disabled, there is a `column_meta` attribute on peewee.NaiveQueryResultWrapper that exposes all the metadata.\r\n\r\n```\r\n>>> type(results)\r\n<class 'peewee.NaiveQueryResultWrapper'>\r\n>>> for f in results.column_meta: print(f.name)\r\nobsid\r\npi_last_name\r\nobs_date\r\nexptime\r\n```", "> Because you may want to write your code in such a way that it can be reused without passing the names of columns explicitly, especially because this information is already part of the results object.\r\n\r\nI definitely get that...especially in a template, like your example.\r\n\r\nI've updated the speedups module to expose the column_meta attribute, see f11802807f5e05dddeb32f93b8c84703b49bb498" ]

[]

[]

[ "I apologize but I don't have the time to read all that code.\r\n\r\nDepending on where you are fork-ing the process, you could definitely run into some problems. It looks from a quick read that you may be forking after you've initialized the connection, etc. This is probably what's causing the problems. You'll need to be sure that you don't initialize any connections until after you fork, as connections cannot be shared among multiple processes...even if you're using the pool.", "Thank you very much four your answer!\r\nI understand you.\r\nIt is true that the connections are created first, then I launch the pool of processes.\r\nWhen I create the connection inside each process, it's just fine !\r\n\r\n```python\r\ndef ProxyModel():\r\n db = InitDB(\"tests\", usr=None, pwd=None, nb_conn=5, mode=\"url\")\r\n proxy = Proxy()\r\n proxy.initialize(db)\r\n return proxy\r\n\r\ndef ReadModelProxy(counter=None):\r\n global _MODELS, _STOP\r\n\r\n proxy = None\r\n # Get recordsets info :\r\n if counter and _STOP.value:\r\n PrintWarn(\"%sERROR IN POOL - Function has been stopped !!!\" % \"counter = %s - \" % counter if counter else \"\")\r\n return\r\n m = _MODELS['p']\r\n if m:\r\n try:\r\n proxy = ProxyModel()\r\n with Using(proxy, [m]):\r\n\r\n rs = m.select()\r\n nb = len(rs)\r\n msg = \"%s%s records found in Modele %s - table = %s\" % (\"counter = %s - \" % counter if counter else \"\", nb, m.__name__, m._meta.db_table)\r\n if nb == 0:\r\n PrintWarn(msg)\r\n else:\r\n PrintOk(msg)\r\n #for p in rs:\r\n # print \"\\t%s was born on %s\" % (p.name, p.birthday)\r\n\r\n except Exception as exc:\r\n PrintError(\"%sERROR : %s\" % (\"counter = %s - \" % counter if counter else \"\", exc))\r\n print traceback.format_exc()\r\n if counter:\r\n _STOP.value = True\r\n finally:\r\n if proxy and not proxy.is_closed():\r\n proxy.close()\r\n return\r\n```\r\nand in main :\r\n```python\r\n # OK : 5th test : \"with pool of processes within proxy peewee\"\r\n MultiProcRead(mode=\"proxy\")\r\n```\r\n\r\nThank-you very much again for all your work!\r\nIt's a great lib!\r\n\r\nPS : Yes, the code seems a bit long: I thought you could just copy/paste it and run as it is!\r\nIt only creates a `persons` table in `tests`mysql` database and adds some data in it.\r\n\r\nThen it does a first simple read of the table test.\r\nAfter that the same read called within a pool of 10 processes.\r\nThis is where I have the errors.\r\n\r\nThe other 2 tests left to show that when I each process runs it's own connection it's ok.\r\n\r\n" ]

[]

[]

[ "I actually found a better way to do it:\r\n\r\n```python\r\nquery = query.from_(SQL(f'`<table_name>` as `t1` USE INDEX(`<index_name>`)'))\r\n```\r\n\r\nIs this the expected way?", "Unfortunately, doing something like this is not really well-supported by Peewee. Your solutions look acceptable but I agree that having to do all that stuff isn't ideal. I don't think that I'll be adding support for this any time soon, so I think you're stuck with implementing this using a less-than-ideal hack." ]

[]

[]

[ "I've merged a patch that adds support manytomany in model_to_dict. Available in Peewee 3.x.\r\n\r\nhttp://docs.peewee-orm.com/en/latest/peewee/playhouse.html#model_to_dict" ]

[]

[]

[ "+1 for this", "This is fixed in 3.0a by 0914cee. Example from test-case:\r\n\r\n```python\r\nclass Owner(TestModel):\r\n name = TextField()\r\n\r\nclass Label(TestModel):\r\n label = TextField()\r\n\r\nclass Gallery(TestModel):\r\n name = TextField()\r\n labels = ManyToManyField(Label, backref='galleries')\r\n owner = ForeignKeyField(Owner, backref='galleries')\r\n\r\nGalleryLabel = Gallery.labels.through_model\r\n\r\n def test_manytomany_field(self):\r\n data = (\r\n ('charlie', 'family', ('nuggie', 'bearbe')),\r\n ('charlie', 'pets', ('huey', 'zaizee', 'beanie')),\r\n ('peewee', 'misc', ('nuggie', 'huey')))\r\n for owner_name, gallery, labels in data:\r\n owner, _ = Owner.get_or_create(name=owner_name)\r\n gallery = Gallery.create(name=gallery, owner=owner)\r\n label_objects = [Label.get_or_create(label=l)[0] for l in labels]\r\n gallery.labels.add(label_objects)\r\n\r\n query = (Gallery\r\n .select(Gallery, Owner)\r\n .join(Owner)\r\n .switch(Gallery)\r\n .join(GalleryLabel)\r\n .join(Label)\r\n .where(Label.label == 'nuggie')\r\n .order_by(Gallery.id))\r\n rows = [model_to_dict(gallery, backrefs=True, manytomany=True)\r\n for gallery in query]\r\n self.assertEqual(rows, [\r\n {\r\n 'id': 1,\r\n 'name': 'family',\r\n 'owner': {'id': 1, 'name': 'charlie'},\r\n 'labels': [{'id': 1, 'label': 'nuggie'},\r\n {'id': 2, 'label': 'bearbe'}],\r\n },\r\n {\r\n 'id': 3,\r\n 'name': 'misc',\r\n 'owner': {'id': 2, 'name': 'peewee'},\r\n 'labels': [{'id': 1, 'label': 'nuggie'},\r\n {'id': 3, 'label': 'huey'}],\r\n }])\r\n```" ]

[]

[]

[]

[]

[]

[ "I'm not sure, if you could put this into a failing test-case that demonstrated a bug in Peewee then I would be happy to look into it. As it is, this type of question is more appropriate for stackoverflow or the peewee mailing list. http://docs.peewee-orm.com/en/latest/peewee/contributing.html#questions" ]

[]

[]

[ "For case-insensitive LIKE you would just use ILIKE.", "You should make that clearer in the docs, this currently isn't evident.", "ILIKE is called ILIKE because it's case-insensitive.", "I get that now, but that's not self-evident. And it's not something you can search the docs for because nowhere does it say the word \"insensitive\"." ]

[]

[]

[ "My bad, I was using wrong db connection" ]

[]

[]

[ "That's odd. Thanks for the report, I'll check it out.", "Thank you @coleifer . Just ping me if you need any additional information.", "What database engine are you using, out of curiosity?", "We are using Sqlite", "Are you using an extension? I'm not familiar with some of the APIs being used:\r\n\r\n```python\r\n MyModel = migrator.orm['my_table'] # XXX\r\n type_new = pw.CharField(null=True, constraints=[pw.Check(\r\n \"type_new in ('type1', 'type2', 'type3')\")])\r\n migrator.add_fields(MyModel, type_new=type_new)\r\n migrator.sql('UPDATE my_table SET type_new=type') # XXX\r\n```", "Seems like we are using peewee-migrate https://github.com/klen/peewee_migrate\r\nIs it better to file issue to that project?", "I think something weird must be going on with that extension.\r\n\r\nRunning this:\r\n\r\n```python\r\nfrom peewee import *\r\nfrom playhouse.migrate import *\r\n\r\ndb = SqliteDatabase('test.db')\r\n\r\nclass TestModel(Model):\r\n data = TextField()\r\n class Meta:\r\n database = db\r\n\r\nTestModel.drop_table(True)\r\nTestModel.create_table()\r\n\r\nm = SqliteMigrator(db)\r\nmigrate(\r\n m.add_column(TestModel._meta.db_table, 'new_column', TextField(null=True)),\r\n)\r\n```\r\n\r\nResults in:\r\n\r\n```\r\n∫ sqlite3 test.db\r\nSQLite version 3.19.0 2017-04-10 12:31:15\r\nEnter \".help\" for usage hints.\r\nsqlite> .schema\r\nCREATE TABLE IF NOT EXISTS \"testmodel\" (\"id\" INTEGER NOT NULL PRIMARY KEY, \"data\" TEXT NOT NULL, \"new_column\" TEXT);\r\n```", "Thank you. Opened new issue https://github.com/klen/peewee_migrate/issues/43", "Cool, feel free to kick it back over here if need be.", "@coleifer, I have a migration:\r\n\r\n```from myapp import db\r\nfrom myapp.models import Message, User\r\nfrom playhouse.migrate import *\r\nfrom playhouse.postgres_ext import *\r\n\r\nmigrator = PostgresqlMigrator(db.database)\r\n\r\ndef up():\r\n\tmigrate(\r\n\t\tmigrator.drop_column('message', 'user_id'),\r\n\t\tmigrator.add_column('message', 'user_id', ForeignKeyField(User, backref='messages')),\r\n\t)\r\n```\r\n\r\nI get following error:\r\n`ValueError: user_id is not null but has no default`\r\n\r\nWhere I was mistaken?", "Why are you dropping and then re-adding it?", "@coleifer \r\nI wanted make changes:\r\n`user = ForeignKeyField(Cert, backref='messages') -> user = ForeignKeyField(User, backref='messages')`", "Is there existing data in that table?", "Yes", "How are you migrating a foreign-key that points to \"Cert\" so that it points instead to \"User\"? Won't the existing values all be incorrect, since originally they reference ``Cert.id`` but will then reference ``User.id``?", "You are right. I deleted all rows.\r\n\r\nhttps://github.com/coleifer/peewee/blob/7e61d86bf6c3f256d09b2a3e1897693dfd68b48d/playhouse/migrate.py#L264-L265\r\n\r\nMy PK dont't have default value and not NULL\r\n\r\n```\r\nif not field.null and field.default is None:\r\n if not is_foreign_key:\r\n raise ValueError('%s is not null but has no default' % column_name)\r\n```", "Well, if you deleted all rows, can you not just drop and re-create the table entirely using the normal `Model.create_table()` API?", "Another option is to add the field and make it nullable, then do a \"drop_not_null()\" afterwards.", "```python\r\n# Just drop and re-create:\r\ndef up():\r\n Message.drop_table()\r\n Message.create_table()\r\n\r\n# OR:\r\ndef up():\r\n\tmigrate(\r\n\t\tmigrator.drop_column('message', 'user_id'),\r\n\t\tmigrator.add_column('message', 'user_id', ForeignKeyField(User, null=True)),\r\n migrator.drop_not_null('message', 'user_id'),\r\n\t)\r\n```" ]

[]

[]

[ "Thanks for reporting this. I've pushed your suggested fix along with a test-case." ]

[]

[]

[ "Is it something not considered as a high priority at the moment?\r\n\r\nI've also seen people trying to implement this, e.g. [here](https://www.quora.com/Is-it-possible-to-swap-in-a-pg8000-backend-for-psycopg2-when-using-Peewee).", "You can implement it by doing something like the above code snippet.\r\n\r\n```python\r\nclass PostgresqlDatabasePG8000(PostgresqlDatabase):\r\n ...\r\n```", "Yeah, but is there any chance it could get official support in peewee in the future?" ]

[]

[]

[ "This is confusing to me -- why use `0` instead of `null`? A zero timestamp corresponds to midnight Jan 1st, 1970.", "Not sure what you're asking. `0` is not the same as `null`, but the `TimestampField` thinks they are. I think it's a bug.", "I guess what I'm asking is why you're using `0` instead of `NULL`, when `0` for a timestamp represents midnight jan 1st, 1970?", "Because I want a non-null value there. `Null` means \"no value\", `0` means \"midnight, Jan 1st, 1970\".\r\n\r\nWhy should the ORM read `0` as `None`? ", "That's fine -- as long as you were aware of the distinction.", "Added support for specifying the zero value for the `TimestampField`. You can now write:\r\n\r\n```python\r\ntimestamp = TimestampField(zero_value=datetime.fromtimestamp(0))\r\n```", "Thanks!" ]

[]

[]

[ "You'll want to be in a transaction in order to rollback, so:\r\n\r\n```python\r\nwith database.atomic():\r\n try:\r\n BgpCommunities.create(...)\r\n except IntegrityError:\r\n # handle exception however.\r\n```", "thanks @coleifer but could you advise bit more, still the connections is locked\r\n```\r\nIn [3]: with database.atomic():\r\n ...: try:\r\n ...: BgpCommunities.create(comm_name=\"BBB\", comm_value=\"6830:2222\", label=\"bbb\", used_as=\"\")\r\n ...: except IntegrityError:\r\n ...: pass\r\n ...: \r\n\r\nIn [4]: BgpCommunities.create(comm_name=\"CCC\", comm_value=\"6830:3333\", label=\"ccc\", used_as=\"generic\")\r\n---------------------------------------------------------------------------\r\nInternalError Traceback (most recent call last)\r\n/usr/lib/python3.4/site-packages/peewee.py in execute_sql(self, sql, params, require_commit)\r\n 3767 try:\r\n-> 3768 cursor.execute(sql, params or ())\r\n 3769 except Exception:\r\n\r\nInternalError: current transaction is aborted, commands ignored until end of transaction block\r\n\r\n\r\nDuring handling of the above exception, another exception occurred:\r\n\r\nInternalError Traceback (most recent call last)\r\n<ipython-input-4-d4d4f5a290c0> in <module>()\r\n----> 1 BgpCommunities.create(comm_name=\"CCC\", comm_value=\"6830:3333\", label=\"ccc\", used_as=\"generic\")\r\n\r\n/usr/lib/python3.4/site-packages/peewee.py in create(cls, **query)\r\n 4913 def create(cls, **query):\r\n 4914 inst = cls(**query)\r\n-> 4915 inst.save(force_insert=True)\r\n 4916 inst._prepare_instance()\r\n 4917 return inst\r\n\r\n/usr/lib/python3.4/site-packages/peewee.py in save(self, force_insert, only)\r\n 5106 rows = 1\r\n 5107 else:\r\n-> 5108 pk_from_cursor = self.insert(**field_dict).execute()\r\n 5109 if pk_from_cursor is not None:\r\n 5110 pk_value = pk_from_cursor\r\n\r\n/usr/lib/python3.4/site-packages/peewee.py in execute(self)\r\n 3524 return self._qr\r\n 3525 else:\r\n-> 3526 cursor = self._execute()\r\n 3527 if not self._is_multi_row_insert:\r\n 3528 if self.database.insert_returning:\r\n\r\n/usr/lib/python3.4/site-packages/peewee.py in _execute(self)\r\n 2910 def _execute(self):\r\n 2911 sql, params = self.sql()\r\n-> 2912 return self.database.execute_sql(sql, params, self.require_commit)\r\n 2913 \r\n 2914 def execute(self):\r\n\r\n/usr/lib/python3.4/site-packages/peewee.py in execute_sql(self, sql, params, require_commit)\r\n 3773 else:\r\n 3774 if require_commit and self.get_autocommit():\r\n-> 3775 self.commit()\r\n 3776 return cursor\r\n 3777 \r\n\r\n/usr/lib/python3.4/site-packages/peewee.py in __exit__(self, exc_type, exc_value, traceback)\r\n 3596 else:\r\n 3597 exc_args = exc_value.args\r\n-> 3598 reraise(new_type, new_type(*exc_args), traceback)\r\n 3599 \r\n 3600 class _BaseConnectionLocal(object):\r\n\r\n/usr/lib/python3.4/site-packages/peewee.py in reraise(tp, value, tb)\r\n 133 def reraise(tp, value, tb=None):\r\n 134 if value.__traceback__ is not tb:\r\n--> 135 raise value.with_traceback(tb)\r\n 136 raise value\r\n 137 elif PY2:\r\n\r\n/usr/lib/python3.4/site-packages/peewee.py in execute_sql(self, sql, params, require_commit)\r\n 3766 cursor = self.get_cursor()\r\n 3767 try:\r\n-> 3768 cursor.execute(sql, params or ())\r\n 3769 except Exception:\r\n 3770 if self.autorollback and self.get_autocommit():\r\n\r\nInternalError: current transaction is aborted, commands ignored until end of transaction block\r\n\r\n```", "Can you share some code I can run locally to reproduce the error?", "Thanks a lot !\r\n\r\nthe table is defined as:\r\n```\r\n# \\d+ bgp_communities \r\n Table \"doc.bgp_communities\"\r\n Column | Type | Modifiers | Storage | Stats target | Description \r\n-------------+--------------------------+-------------------------------------------------------------+----------+--------------+-------------\r\n i | integer | not null default nextval('bgp_communities_i_seq'::regclass) | plain | | \r\n comm_name | text | not null | extended | | \r\n comm_value | text | not null | extended | | \r\n label | text | not null | extended | | \r\n used_as | text | not null | extended | | \r\n modified_on | timestamp with time zone | default now() | plain | | \r\nIndexes:\r\n \"bgp_communities_pkey\" PRIMARY KEY, btree (i)\r\n \"bgp_communities_comm_value_key\" UNIQUE CONSTRAINT, btree (comm_value)\r\nCheck constraints:\r\n \"bgp_communities_comm_value_check\" CHECK (comm_value ~ similar_escape('%:%'::text, NULL::text) OR comm_value ~ similar_escape('%:%:%'::text, NULL:\r\n:text))\r\n \"bgp_communities_used_as_check\" CHECK (used_as = ANY (ARRAY['bgp-customer'::text, 'destination'::text, 'dtv-peer'::text, 'free-peer'::text, 'gener\r\nic'::text, 'infrastructure'::text, 'origin'::text, 'private-peer'::text, 'public-peer'::text, 'traffic-eng'::text, 'voip-peer'::text]))\r\nHas OIDs: no\r\n```\r\n\r\nand the model generator produces:\r\n```\r\n$ python3 -m pwiz --engine=postgresql --host= --port=5432 --user= --password --schema=doc --tables=bgp_communities ip_spotlight\r\nPassword: \r\nfrom peewee import *\r\n\r\ndatabase = PostgresqlDatabase('ip_spotlight', **{'password': '', 'host': '', 'port': 5432, 'user': ''})\r\n\r\nclass UnknownField(object):\r\n def __init__(self, *_, **__): pass\r\n\r\nclass BaseModel(Model):\r\n class Meta:\r\n database = database\r\n\r\nclass BgpCommunities(BaseModel):\r\n comm_name = TextField()\r\n comm_value = TextField(unique=True)\r\n i = PrimaryKeyField()\r\n label = TextField()\r\n modified_on = DateTimeField(null=True)\r\n used_as = TextField()\r\n\r\n class Meta:\r\n db_table = 'bgp_communities'\r\n schema = 'doc'\r\n\r\n```\r\n\r\nthis query is correct:\r\n`BgpCommunities.create(comm_name=\"CCC\", comm_value=\"6830:3333\", label=\"ccc\", used_as=\"generic\")`\r\nthis query is wrong:\r\n`BgpCommunities.create(comm_name=\"BBB\", comm_value=\"6830:2222\", label=\"bbb\", used_as=\"\")`\r\n\r\nand the `database` is initialised like ` database = PostgresqlDatabase('ip_spotlight', autocommit=True, autorollback=True, **`", "Hello, \r\n\r\nAny updates on this topic? There had beed no answer and the question is closed. I am having the same issue with connection to postgres being locked even after calling db.rollback() like suggested + db.close() at the end of the function does not release the connection.\r\n\r\nAny further suggestions?", "I cannot advise what the issue may be, but I don't think it's a peewee issue in that case. It doesn't make sense to me why rolling-back and closing the connection would have no effect, unless you're also using the connection-pool or have omitted other important information.", "I was having an issue with the same symptom. In my case, the problem was solved by specifying `autorollback=True` when creating the database.", "This error usually surfaces after an `IntegrityError` has been raised. When using postgres and a constraint is violated, you need to abort the transaction by calling `db.rollback()`. This is handled automatically if you are using the `atomic()` / `transaction()` etc context-managers." ]

[]

[]

[ "Yes, this is fixed in sqlite-web. See the issue there: https://github.com/coleifer/sqlite-web/issues/30", "sqlite-web 0.1.8 was released as well, fixing the issue if you try again." ]

[]

[]

[ "Version:\r\n- Python: 3.6.1\r\n- peewee: 2.10.1 ", "d68ae11501face8f4eb6adfde82d8eda79728dc7" ]

[]

[]

[ "Version:\r\n- Python: 3.6.1\r\n- peewee: 2.10.1 ", "The problem is the \"_id\" suffix. DataSet relies on the introspection tools in the `playhouse.reflection` module. These tools are used to read the database and generate peewee Model definitions. There's a convention in peewee, borrowed from Django, to append \"_id\" to foreign key fields. So if I have a Tweet and User model, and the Tweet.author is a foreign key to a User, the column will actually be called Tweet.author_id (though the field name is \"author\"). This comes into play when introspecting, which does the inverse -- if it sees a column named \"xxx_id\", it will strip the \"_id\" from the field name (preserving it for the column).\r\n\r\nI'll look into how to fix this, at any rate.", "d68ae11501face8f4eb6adfde82d8eda79728dc7", "Thanks for the quick fix and support. ", "For sure, thanks for the nice reports." ]

[]

[]

[ "Just one hint: you need to call `switch()` here:\r\n\r\n```python\r\nquery = (Campaign\r\n .select(Campaign, User, Channel)\r\n .join(User, on=(Campaign.user == User.id))\r\n .switch(Campaign) # ADD THIS.\r\n .join(Channel, on=(Campaign.channel == Channel.id))\r\n .where(Campaign.state == state)\r\n .order_by(Campaign.name)\r\n .paginate(page, 10))\r\n```\r\n\r\nSecondly, why not try using the `model_to_dict` helper? I don't see why it would be more code or why you'd need to explicitly create the dictionary:\r\n\r\n```python\r\ncampaigns = [model_to_dict(campaign, recurse=True) for campaign in query]\r\n```", "You are complety right. I don't need do that. I've applied what you do and works fine. Thanks for clarify this and forgive me if was a silly question, I have little time with Python. Thanks again; I going to close this thread.", "Not silly at all, glad to help.", "Hi @coleifer I didn't open a new issue because it's related with this.\r\n\r\nI have a problem using `model_to_dict` on a join query where the foreign key is on inverse side.\r\n\r\n```python\r\nclass User(Base):\r\n name = CharField(null=False)\r\n photo = CharField()\r\n email = CharField(unique=True, null=False)\r\n password = CharField(null=False)\r\n website = CharField(unique=True, null=False)\r\n role = CharField(null=False, default=\"user\")\r\n reason = TextField(null=True)\r\n state = CharField(null=False, default=\"waiting\")\r\n created_at = DateTimeField(null=False, default=datetime.now())\r\n\r\nclass Wallet(Base):\r\n user = ForeignKeyField(User, null=False, related_name=\"wallet\")\r\n funds = DoubleField(null=False, default=0.0)\r\n```\r\nSo, I did this query to get all users with their wallets:\r\n\r\n```python\r\nqs = Box(request.args, default_box=True)\r\n page = int(qs.page[0])\r\n state = qs.state[0]\r\n query = (User\r\n .select(User, Wallet)\r\n .join(Wallet)\r\n .switch(User)\r\n .where(User.state == state)\r\n .order_by(User.name)\r\n .paginate(page, 10))\r\n```\r\nIf iterate the query accesing to the `wallet.funds` field, it works (show me available users funds). But when I try to convert it to dicts the wallet field is missing:\r\n\r\n```python\r\nusers = [model_to_dict(user, recurse=True) for user in query]\r\nfor user in users:\r\n print(user.get(\"wallet\", \"There is no wallet\")) # prints \"There is no wallet\"\r\n```", "That's because, due to the way you've modeled the data, a User may have many wallets. So model_to_dict isn't able to infer, ahead-of-time, that a user will 0, 1, or many wallets. If you want to include back-references, just call `model_to_dict` with `backrefs=True` (in addition to `recurse=True`) and the wallets will be included as a list.", "This is all very clearly documented, in my opinion: http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#model_to_dict\r\n\r\nPlease let me know if you found the docs confusing." ]

[]

[]

[ "Try property indenting and surrounding your code in code blocks.", "Please take the extra minute to ensure your code is properly formatted. I've done it for you this time as a courtesy.", "There is something wrong in your code or in the state of your database, because I get an error (as expected):\r\n\r\n```python\r\nTraceback (most recent call last):\r\n File \"x.py\", line 25, in <module>\r\n obj = Lista.get(Lista.cuenta == \"test\")\r\n File \"/home/charles/pypath/peewee.py\", line 4926, in get\r\n return sq.get()\r\n File \"/home/charles/pypath/peewee.py\", line 3185, in get\r\n % self.sql())\r\n__main__.ListaDoesNotExist: Instance matching query does not exist:\r\nSQL: SELECT \"t1\".\"id\", \"t1\".\"cuenta\", \"t1\".\"tiempo\" FROM \"lista\" AS t1 WHERE (\"t1\".\"cuenta\" = ?)\r\n```" ]

[]

[]

[ "I don't think that this makes sense. What does it mean to \"call\" a db variable anyways? I think it's clear enough." ]

[]

[]

[ "This is not Peewee, this is Python. The database attribute of the Model's `Meta` class holds a reference to the `db` object a module scope... This is resolved at module-load time. So no magic.", "@ardeaf That's an easy mistake to make. If you want to be absolutely sure to use the right connection, I think you could do:\r\n\r\n with BaseModel.Meta.database.atomic():\r\n\r\nBut that's super ugly, yeah..." ]

[]

[]

[ "I found a bug in the Python implementation of the default rank() function...the Cython version worked fine, but the Python version wasn't respecting the weights parameter due to some careless variable naming on my part. When I run it locally, I now get the following output:\r\n\r\n```python\r\n(u'mario', -2.0)\r\n(u'documento', -1.0)\r\n(u'documento', u'mario', -0.0)\r\n(u'mario', u'descrizione', -0.0)\r\n```\r\n\r\nThis doesn't address your question about BM25, but the BM25 scoring function is actually unit-tested and I know from using it on my own projects that it does work. To ensure this, I've added an additional unit-test that specifically tests the weight parameter. You can view the code here: cfd5aee9f85352a7a7b0054467eaa0d6ad5b87d9\r\n\r\nI think that perhaps the `0.` results are simply a result of the sample size being so constrained." ]

[]

[]

[ "These methods are very confusingly named -- apologies for that.\r\n\r\nHistory:\r\n\r\nOriginally, you would use `Model.create_table()` which would create the table along with the indexes and other constraints. The `Database.create_table()` method was used behind-the-scenes and it **only** creates the table -- not indexes.\r\n\r\nThen I realized there is a common situation where you need to create many tables, and create them in the right order so that the dependency graph is created correctly. To accomplish this, I added the `Database.create_tables()` method (table**s**). It accepts a list of models, does a topological sort to obtain a total ordering, then calls `Model.create_table()` on each table in succession, which ensures the indexes are created as well.\r\n\r\nSo, long story short, `Database.create_table()` should not be used unless you have a very specific reason for using it.\r\n\r\nYou should use `Model.create_table()` to create a single model's table & indexes, and `Database.create_tables()` when you want to create tables & indexes for more than one model.", "Ok! Thanks for your long story and long story short !!\r\n It entirely solve my problem!🤣😇" ]

[]

[]

[]

[]

[]

[ "That works perfectly in the end. My mistake was elsewhere.\r\n\r\nHave a nice day!" ]

[]

[]

[ "It seems maybe someone should look into the pypi package. I installed via git, and that seemed fine.", "Thanks for bringing this to my attention. Pushed a new minor release and verified it is working correctly for me using 2.7 and 3.6 + PyPI." ]

[]

[]

[ "Uhhhh", "@coleifer Sorry about that, I just don't want to make trash here." ]

[]

[]

[ "@cym13 -- may I ask what you intend to use the `AESEncryptedField` for? Is this for an application you're working on?", "Sorry, I should've added -- I definitely intend to address the issues you've raised. Thanks. I also edited the title of the comment to be a little more representative of the situation.\r\n\r\nThe code I'm using **is mostly based on the example in pycrypto itself**, [you can see here](https://pypi.python.org/pypi/pycrypto):\r\n\r\n```python\r\n>>> from Crypto.Cipher import AES\r\n>>> obj = AES.new('This is a key123', AES.MODE_CBC, 'This is an IV456')\r\n>>> message = \"The answer is no\"\r\n>>> ciphertext = obj.encrypt(message)\r\n>>> ciphertext\r\n'\\xd6\\x83\\x8dd!VT\\x92\\xaa`A\\x05\\xe0\\x9b\\x8b\\xf1'\r\n>>> obj2 = AES.new('This is a key123', AES.MODE_CBC, 'This is an IV456')\r\n>>> obj2.decrypt(ciphertext)\r\n'The answer is no'\r\n```\r\n\r\nVersus peewee:\r\n\r\n```python\r\n def get_cipher(self, key, iv):\r\n if len(key) > 32:\r\n raise ValueError('Key length cannot exceed 32 bytes.')\r\n key = key + bytes(' ') * (32 - len(key))\r\n return AES.new(key, AES.MODE_CFB, iv)\r\n\r\n def encrypt(self, value):\r\n iv = Random.get_random_bytes(AES.block_size)\r\n cipher = self.get_cipher(self.key, iv)\r\n return iv + cipher.encrypt(value)\r\n\r\n def decrypt(self, value):\r\n iv = value[:AES.block_size]\r\n cipher = self.get_cipher(self.key, iv)\r\n return cipher.decrypt(value[AES.block_size:])\r\n\r\n```", "I don't use this field myself, someone else I know does. Maybe he'll come comment himself he he feels like so.\r\n\r\nWhat PyCrypto does is completely different from what your code does and the PyCrypto snippet you choose shows nothing of its internal mechanics. I'm sorry, but there's no way arround it: AESEncryptedField is broken and endangers its users. Maybe I'll take some time this weekend to demonstrate actual decryption, the flaw is important enough that I have no doubt about the feasibility of it. It's not one of those theoretical issues.\r\n\r\nAs a side note I would recommend against taking PyCrypto as a reference when it comes to security. The project is very flawed itself with some vulnerabilities that aren't likely to be fixed ever (https://github.com/dlitz/pycrypto/issues/176). The API makes it very easy to get things wrong too. Try https://pypi.python.org/pypi/cryptography or PyCryptodome which is a fork of PyCrypto if you need compatibility.", "Thanks for the explanation. I'll go ahead and remove the field, that seems like the best option.", "Removed for 2.10.0: https://github.com/coleifer/peewee/releases/tag/2.10.0 -- thanks for bringing these problems to my attention." ]

[]

[]

[ "Related to: https://github.com/coleifer/peewee/issues/1262", "The tests for the playhouse extra_fields are not run automatically. Is there a particular reason?", "Will all those byte literals be compatible with Python 2.6?", "See comments on #1262 and #1264 " ]

[]

[]

[ "This field has been removed in the latest release, 2.10.0. For details and explanation of why, see https://github.com/coleifer/peewee/releases/tag/2.10.0" ]

[]

[]

[ "Cool thankee" ]

[]

[]

[ "@kszucs Have you seen https://github.com/05bit/peewee-async ?", "Sure. Peewee-async uses another approach, with a centralized manager object.", "@kszucs Neat. Does aiopeewee only support Postgres right now?", "Only Mysql, but postgres support is easy to implement - need to port only a couple of methods. " ]

[]

[]

[ "You can do this yourself. I assume you have a MySQLDatabase subclass that you intend to use.... You can, then:\r\n\r\n```python\r\n\r\nfrom playhouse.db_url import connect, register_database\r\n\r\nregister_database(MySQLDatabaseSubClass, 'mysqlretry')\r\ndb = connect('mysqlretry://....')\r\n```" ]