Datasets:

---

akumoth

/

peewee-issues

like 0

[]

[]

[ "I'm not sure what all is going on in the error you pasted. I literally have no idea.\n", "My best guess so far is that speedups are probably missing some kind of definition to match PyPy's C headers. Cython also has issues with PyPy, so these probably need to move to cffi or something.\n\nEither way, I need to figure out how to disable speedups when installing under PyPy...\n", "Updated setup.py f42aa3cc76d7f3506fe714355626f4a771652c3c\n" ]

[]

[]

[ "These are optional keyword arguments. The arguments in brackets are shown with their default values (if they have one).\n", "I understand that brackets indicate optional arguments; I'm asking why they're nested.\n", "Because that's how you do it. https://docs.python.org/3/library/collections.html#collections.deque\n" ]

[]

[]

[ "I'm not following this at all. \n", "The signals all have a disconnect method, so you could use that. Alternatively you could use a global variable or thread local to keep track of the state.\n" ]

[]

[]

[ "Argh. This can be closed. After posting, I wondered why I was using FlaskDB in the first place. I updated my code to just connect/disconnect before/after app requests. No FlaskDB needed.\n\n``` python\[email protected]_request\ndef connect_proxy():\n initialize_proxy()\n proxy.connect()\n\[email protected]_request\ndef close_proxy(exc):\n if not proxy.is_closed():\n proxy.close()\n```\n" ]

[]

[]

[ "Can you explain in greater detail? Peewee stores the connection state in a thread-local, so each thread should by default have its own connection.\n", "Whatever, closing.\n", "Please comment if you have any information you can provide to clarify the issue.\n" ]

[]

[]

[ "Was just running through your awesome tutorial and caught an error when playing with it. Figured I'd submit a PR.\n", "I appreciate the intentions, but your change-set has more problems than it attempts to solve. I've fixed the underlying issue with 6a07c8e1d949724ae10c9e304b1d7d30214cf2c6\n", "Oh shoot I didn't copy over my whole change. I had added an additional line after the flash to render_template('create.html') in my local code, forked and made a quick change in github's editor. But reading over your fix I suspect there's a good reason why that's also not the best option. \n", "The reason it's not a good option (and whoops I need to fix something else, just remembered) is because you lose all your changes that you had been working on.\n", "Oh actually nvm, I see that the template is pulling straight from request.form. Nevermind!\n" ]

[]

[]

[ "I appreciate you taking the time to submit this issue. Unfortunately, peewee does quite a few things that many linters find egregious. I don't use linters myself, so it doesn't bother me and personally I'm not interested in adding code simply to satisfy flake8. Thanks for providing a reference implementation, anyone who is interested can use your code or subclass `BooleanField` and add the suggested methods.\n", "I'm also not concerned with the peewee code style, I'm concerned that peewee is clearly forcing its users to take a move against PEP8 when using boolean fields, besides the consistency with `is_null`. I mean, what I propose is about the API, not about the peewee code itself.\n", "Peewee isn't forcing anyone to do anything.\n", "It's not forcing people to become peewee users, but it's forcing its users to follow its API.\n\nThe `== True` is spread in the documentation examples. Is there any example with some different approach to avoid `Something.my_field == True` while doing the same? I might be missing something.\n", "> Is there any example with some different approach to avoid `Something.my_field == True` while doing the same?\n\nYou've shared a nice one.\n", "A lot of things have changed since this discussion, and I think the original \"gripe\" has been fixed. But I wanted to confirm...\r\n\r\nThe main point is that you no longer need to use the `== True/False` syntax, though there are certain cases where it could be necessary (mainly when dealing with NULL values)\r\n\r\n\r\n```SQL\r\n q1 = Event.select(Event.id).where(Event.is_published)\r\n print(q1)\r\n >> SELECT `t1`.`id` FROM `event` AS `t1` WHERE `t1`.`is_published`\r\n\r\n q1 = Event.select(Event.id).where(~Event.is_published)\r\n print(q1)\r\n >> SELECT `t1`.`id` FROM `event` AS `t1` WHERE NOT `t1`.`is_published`\r\n\r\n q1 = Event.select(Event.id).where(Event.is_published == True)\r\n print(q1)\r\n >> SELECT `t1`.`id` FROM `event` AS `t1` WHERE (`t1`.`is_published` = 1)\r\n\r\n q1 = Event.select(Event.id).where(Event.is_published == False)\r\n print(q1)\r\n >> SELECT `t1`.`id` FROM `event` AS `t1` WHERE (`t1`.`is_published` = 0)\r\n```\r\n\r\nUsually both versions will be equivalent. But if the boolean field supports NULL, then you need to be careful which version you use.\r\n\r\nThe same things goes for hybrid attributes. The reason I arrived at this ticket was because I noticed a query was not using an index that it should have been. It was using the `== False` syntax on a hybrid attribute/expression, which resulted in the query being something like `WHERE (( complex expression ) == 0)`, but when using the negation operator `~`, the SQL is `WHERE NOT ( complex expression)` and the index was used correctly. \r\n\r\n\r\nThe documentation seems to mainly still use the `== True/False` variation. Maybe I missed it, but it could be good to add some details on the difference between these two variations of boolean expressions." ]

[]

[]

[ "You can add a constraint:\n\n``` python\ncolumn = CharField(constraints=[SQL('COLLATE NOCASE')])\n```\n" ]

[]

[]

[ "> Inserting TimestampFied with value: 1475411420001 will be stored in the MySQL database as 1475411420001000.\n> Although the resolution of the field is set to milliseconds (1.000) and not to microseconds (1.000.000)\n\nIt looks to me like you've over-thought it and done the multiplication yourself. The purpose of the `TimestampField` is to make all that unnecessary. `TimestampField` allows you to work with `datetime` objects in Python but store them as integers in the database. If you want to explicitly pass in a timestamp as an integer or floating point, then Peewee will scale that accordingly before storing it.\n" ]

[]

[]

[ "Are you running on the current, very latest commit? Because `sqliteq`'s `atomic()` is kinda broken right now in a totally different way, as I'm in the process of implementing something like a pipeline in Redis.\n", "Yeah, that's why I mentioned the commit hash. Not sure if you want feedback on your current development code.\n" ]

[]

[]

[ "I'd like to add something like this, but am worried about breaking too many people's code... I'll look into a similar patch.\n", "9e76c999868197a4911fa2fa457c50ab42431ff1\n", "Thanks!\n", "FYI: this did break our code like you mentioned above. I can work around it in our codebase but I expect this caused problems for a lot of people; is there any more robust way of doing this?", "Just run `database.get_conn()` which will only open a connection if the DB is closed." ]

[]

[]

[ "Nice, thanks for this.\n" ]

[]

[]

[ "I think I'm going to pass on fixing this, as it's a bit of a slippery slope in terms of supporting every data-type. I'd suggest just doing as you showed, and coerce to list.\n", "Can `Node._in` coerce to list automatically? [`list`](https://docs.python.org/2.6/library/functions.html#list) accepts any iterable, so the only thing the data-type needs to implement is the iterator.\n\nThat would work also with generators:\n\n```\n# Python 3\nUser.select().where(User.id << range(1, 10))\n```\n" ]

[]

[]

[ "Traditionally, peewee hasn't supported this explicitly. Though with SQLite's new row-values stuff getting released I think it should, so I'll look at a patch.\n", "I haven't tried yet, but I just suddenly thought that I maybe could get what I want using `CommaClause`, couldn't I?\n", "Yes that should certainly work.\n", "In fact most likely that's how I'll end up implementing this: interpret tuples as CommaClause.\n", "Actually, and of course I should have realized this, the Python interpreter won't let us override the comparators for tuples, so writing:\n\n```\n(User.id, User.username) == (1, 'user-1')\n```\n\nWill be evaluated by the Python interpreter (as `True`) and at no point are we aware that the comparison is operating on a 2-tuple.\n\nSo for now, if you wish to use tuples in Peewee, you should use the new `Tuple` class (available if you `from peewee import *`). The `Tuple` class is simply an alias for `EnclosedClause`, as you had suggested.\n\nHere is how you would express the above:\n\n```\nTuple(User.id, User.username) == (1, 'user-1')\n```\n", "Hi @coleifer , I was looking for a way to express [SQLite Row Values](https://www.sqlite.org/rowvalue.html#search_against_multi_column_keys) and only found the solution above by chance.\r\nI believe this should be documented, and I'm willing to write a few words about it.\r\nWhere do you think it would be more appropriate?\r\nPerhaps in the [Expressions section of the Query Operators chapter](http://docs.peewee-orm.com/en/latest/peewee/query_operators.html?highlight=where#expressions)?", "Added some docs.", "http://docs.peewee-orm.com/en/latest/peewee/query_operators.html#row-values" ]

[]

[]

[ "It appears this could be due to low memory. I'll check that possibility.\n", "Okay, after some digging, I got this. \n\nThe segfault is a `SIGSEGV`. \n\nHere's the backtrace from gdb\n\n```\n#0 0x00000000005377c7 in _PyObject_GC_New ()\n#1 0x00000000005379da in PyDict_New ()\n#2 0x00000000004ad2fd in _PyObject_GenericSetAttrWithDict ()\n#3 0x00000000004ad9dd in PyObject_SetAttr ()\n#4 0x000000000049a356 in PyEval_EvalFrameEx ()\n#5 0x00000000004a1c9a in ?? ()\n#6 0x00000000004dfe94 in ?? ()\n#7 0x0000000000505f96 in PyObject_Call ()\n#8 0x00000000004de41a in ?? ()\n#9 0x00000000005039eb in ?? ()\n#10 0x0000000000499be5 in PyEval_EvalFrameEx ()\n#11 0x0000000000499ef2 in PyEval_EvalFrameEx ()\n#12 0x0000000000499ef2 in PyEval_EvalFrameEx ()\n#13 0x00000000004a1c9a in ?? ()\n#14 0x00000000004dfe94 in ?? ()\n#15 0x0000000000505f96 in PyObject_Call ()\n#16 0x00000000004cac9f in ?? ()\n#17 0x000000000049990f in PyEval_EvalFrameEx ()\n#18 0x00000000004a1c9a in ?? ()\n#19 0x0000000000505f96 in PyObject_Call ()\n#20 0x000000000049b07a in PyEval_EvalFrameEx ()\n#21 0x0000000000499ef2 in PyEval_EvalFrameEx ()\n#22 0x0000000000499ef2 in PyEval_EvalFrameEx ()\n#23 0x0000000000499ef2 in PyEval_EvalFrameEx ()\n#24 0x00000000004a1c9a in ?? ()\n#25 0x00000000004dfe94 in ?? ()\n#26 0x0000000000505f96 in PyObject_Call ()\n#27 0x00000000004dddad in ?? ()\n#28 0x0000000000499be5 in PyEval_EvalFrameEx ()\n#29 0x00000000004a090c in PyEval_EvalCodeEx ()\n#30 0x000000000049ab45 in PyEval_EvalFrameEx ()\n#31 0x00000000004a090c in PyEval_EvalCodeEx ()\n#32 0x000000000049ab45 in PyEval_EvalFrameEx ()\n#33 0x00000000004a090c in PyEval_EvalCodeEx ()\n#34 0x000000000049ab45 in PyEval_EvalFrameEx ()\n#35 0x00000000004a1c9a in ?? ()\n#36 0x00000000004dfe94 in ?? ()\n#37 0x0000000000499be5 in PyEval_EvalFrameEx ()\n#38 0x00000000004a090c in PyEval_EvalCodeEx ()\n#39 0x000000000049ab45 in PyEval_EvalFrameEx ()\n#40 0x00000000004a1c9a in ?? ()\n#41 0x00000000004dfe94 in ?? ()\n#42 0x0000000000505f96 in PyObject_Call ()\n#43 0x00000000004de41a in ?? ()\n#44 0x00000000005039eb in ?? ()\n#45 0x0000000000499be5 in PyEval_EvalFrameEx ()\n#46 0x0000000000499ef2 in PyEval_EvalFrameEx ()\n#47 0x0000000000499ef2 in PyEval_EvalFrameEx ()\n#48 0x0000000000499ef2 in PyEval_EvalFrameEx ()\n#49 0x00000000004a1c9a in ?? ()\n#50 0x00000000004dfe94 in ?? ()\n#51 0x0000000000499be5 in PyEval_EvalFrameEx ()\n#52 0x00000000004a090c in PyEval_EvalCodeEx ()\n---Type <return> to continue, or q <return> to quit---\n#53 0x000000000049ab45 in PyEval_EvalFrameEx ()\n#54 0x00000000004a090c in PyEval_EvalCodeEx ()\n#55 0x000000000049ab45 in PyEval_EvalFrameEx ()\n#56 0x00000000004a1c9a in ?? ()\n#57 0x0000000000505f96 in PyObject_Call ()\n#58 0x000000000049b07a in PyEval_EvalFrameEx ()\n#59 0x00000000004a090c in PyEval_EvalCodeEx ()\n#60 0x0000000000499a52 in PyEval_EvalFrameEx ()\n#61 0x00000000004a1634 in ?? ()\n#62 0x000000000044e4a5 in PyRun_FileExFlags ()\n#63 0x000000000044ec9f in PyRun_SimpleFileExFlags ()\n#64 0x000000000044f904 in Py_Main ()\n#65 0x00002aaaaaf0ff45 in __libc_start_main (main=0x44f9c2 <main>, argc=2, argv=0x7fffffffe678, init=<optimized out>, fini=<optimized out>, rtld_fini=<optimized out>,\n stack_end=0x7fffffffe668) at libc-start.c:287\n\n```\n\nFrom the function call at the top, I decided to up the stack size with `ulimit -s unlimited`, which was not successful. So, I'm now doubting whether its memory. I don't know if its due to the list comprehension or not, I'll try putting the list comprehension in a function and converting it to a for loop, to confirm if it is stack size related. \n", "Its memory related. Ran out of memory while loading the records. Closing\n" ]

[]

[]

[ "Used `from_` keyword.\n\n``` python\n subq = (HistRec\n .select(fn.unnest(fn.string_to_array(HistRec.medserv, ' ')).alias('ms'))\n .where(HistRec.state == 1)\n .alias('subq'))\n\n qs = (HistRec\n .select(subq.c.ms, fn.count(subq.c.ms))\n .from_(subq)\n .group_by(subq.c.ms)\n .order_by(subq.c.ms))\n```\n\n@coleifer thanks for perfect ORM!\n", "Glad you got it sorted out!\n" ]

[]

[]

[ "You neglected to share the only the thing I really need to debug this: the model definition!\n", "AH, my bad. Here you go!\n\n```\nclass customer(BaseModel):\n entityId = ForeignKeyField(null=True, rel_model=entity, on_delete=\"SET NULL\")\n parent = ForeignKeyField(null=True, rel_model='self', on_delete=\"SET NULL\")\n billingAddressId = ForeignKeyField(null=True, rel_model=address, on_delete=\"SET NULL\")\n customerType = EnumField(null=True, choices=('Customer', 'Lead'))\n accountNumber = CharField(null=True, max_length=16)\n name = CharField(null=True, max_length=32)\n active = BooleanField(null=True, default=True)\n taxable = BooleanField(null=True, default=False)\n membershipId = ForeignKeyField(null=True, rel_model=ACmembership, on_delete=\"SET NULL\")\n taxItem = ForeignKeyField(null=True, rel_model=tax, on_delete=\"SET NULL\")\n laborRateAmount = DecimalField(null=True, max_digits=10, decimal_places=3)\n laborChargeRate = EnumField(null=True, choices=('Flat Rate', 'Hourly'))\n billForDriveTime = BooleanField(null=True, default=False)\n discount = DecimalField(null=True, max_digits=10, decimal_places=3)\n discountType = EnumField(null=True, choices=('%', '$'))\n referralSourceId = ForeignKeyField(null=True, rel_model=ACreferralSource, on_delete=\"SET NULL\")\n paymentTermsId = ForeignKeyField(null=True, rel_model=ACCpaymentTerms, on_delete=\"SET NULL\")\n defaultPaymentMethodId = ForeignKeyField(null=True, rel_model=ACCpaymentMethod, on_delete=\"SET NULL\")\n defaultCurrencyId = ForeignKeyField(null=True, rel_model=ACCcurrency, on_delete=\"SET NULL\")\n lastUpdated = DateTimeField(null=True, default=datetime.utcnow())\n```\n\nAnd here's the EnumField def as well:\n\n```\nclass EnumField(Field):\n db_field = \"enum\"\n\n def coerce(self, value):\n if value not in self.choices:\n raise Exception(\"Invalid Enum Value `%s`\", value)\n return str(value)\n\n def get_column_type(self):\n return \"ENUM\"\n\n def get_modifiers(self):\n return ['\"%s\"' % choice for choice in self.choices]\n```\n", "I believe it's the EnumField which has a \"%\" character. Sqlite gets upset if you explicitly pass in `None`, so that's the inverse of this particular issue (which would be solved by passing in `params or None` instead of `params or ()`). I could move this out into a db-specific parameter, I suppose...but what if you tried passing in a double percent instead of a single percent? Also if you could share the relevant ddl-generation portions of `EnumField` that'd be awesome.\n", "Here's what _query_ looks like at this point:\n\n``` python\n# in MySQLdb/cursor.py/\n def execute(self, query, args=None):\n del self.messages[:]\n db = self._get_db()\n if isinstance(query, unicode):\n query = query.encode(db.unicode_literal.charset)\n if args is not None:\n if isinstance(args, dict):\n query = query % dict((key, db.literal(item))\n for key, item in args.iteritems())\n else:\n # <--- sql below is what query looks like here --->\n query = query % tuple([db.literal(item) for item in args])\n```\n\n``` sql\nCREATE TABLE `customer` (\n `id` INTEGER AUTO_INCREMENT NOT NULL PRIMARY KEY,\n `entityId_id` INTEGER,\n `parent_id` INTEGER,\n `billingAddressId_id` INTEGER,\n `customerType` ENUM (\"Customer\", \"Lead\"),\n `accountNumber` VARCHAR(16),\n `name` VARCHAR(32),\n `active` BOOL,\n `taxable` BOOL,\n `membershipId_id` INTEGER,\n `taxItem_id` INTEGER,\n `laborRateAmount` NUMERIC(10, 3),\n `laborChargeRate` ENUM (\"Flat Rate\", \"Hourly\"),\n `billForDriveTime` BOOL,\n `discount` NUMERIC(10, 3),\n `discountType` ENUM (\"%\", \"$\"),\n `referralSourceId_id` INTEGER,\n `paymentTermsId_id` INTEGER,\n `defaultPaymentMethodId_id` INTEGER,\n `defaultCurrencyId_id` INTEGER,\n `lastUpdated` DATETIME,\n FOREIGN KEY (`entityId_id`) REFERENCES `entity` (`id`)\n ON DELETE SET NULL,\n FOREIGN KEY (`parent_id`) REFERENCES `customer` (`id`)\n ON DELETE SET NULL,\n FOREIGN KEY (`billingAddressId_id`) REFERENCES `address` (`id`)\n ON DELETE SET NULL,\n FOREIGN KEY (`membershipId_id`) REFERENCES `acmembership` (`id`)\n ON DELETE SET NULL,\n FOREIGN KEY (`taxItem_id`) REFERENCES `tax` (`id`)\n ON DELETE SET NULL,\n FOREIGN KEY (`referralSourceId_id`) REFERENCES `acreferralsource` (`id`)\n ON DELETE SET NULL,\n FOREIGN KEY (`paymentTermsId_id`) REFERENCES `accpaymentterms` (`id`)\n ON DELETE SET NULL,\n FOREIGN KEY (`defaultPaymentMethodId_id`) REFERENCES `accpaymentmethod` (`id`)\n ON DELETE SET NULL,\n FOREIGN KEY (`defaultCurrencyId_id`) REFERENCES `acccurrency` (`id`)\n ON DELETE SET NULL\n)\n```\n", "Well, in the implementation of the EnumField, I wonder if it'd be better to parameterize the values it accepts...is this possible? i.e. it would generate DDL like `SQL('ENUM (%s))' % ', '.join('%s' for _ in values), values)`.\n\nWDYT?\n", "How is that different from what it does now? The generated sql is correct and making it all the way to the execute method without issue. If this was an issue, wouldn't it cause problems in generating the field sql instead when trying to execute? By the time the generated sql gets to the db, the string formatting for the fields has been done. \n", "I verified that double % works. Sorry to waste your time. It wasn't obvious to me at first why that would fail. Thanks for looking into it though.\n", "Its completely non obvious! Glad we got it fixed.\n", "I have an application that must support both Sqlite and MySQL. How can I make the above `EnumField` compatible with `SqliteDatabase`? When I use the option `field_types={\"ENUM\": \"TEXT\"}`, the produced DDL is not valid for Sqlite:\r\n\r\n customerType TEXT(\"Customer\", \"LEAD\")\r\n\r\nInstead I want `customerType TEXT`." ]

[]

[]

[ "This would need to be implemented in the application. You can use `SIGALARM` to do this:\n\n``` python\ndef long_query(signal, frame):\n # handle long running query here\n pass\n\nsignal.signal(signal.SIGALRM, long_query)\nsignal.alarm(number_of_seconds_to_timeout)\ntry:\n execute_some_slow_query()\nfinally:\n signal.alarm(0) # Clear alarm if we succeed before timing out.\n```\n\nYou can, if using SQLite, look into the progress handler: https://docs.python.org/3/library/sqlite3.html#sqlite3.Connection.set_progress_handler\n" ]

[]

[]

[ "Correct, I can see about improving the code to include these types of constraints.\n", "To be honest, there is no piece of code I regret more than get_or_create. It's so easy to write your own version that's specific to your model. But a general purpose one is complicated. Ugh.\n", "I think I'm actually going to remove get_or_create because of all the headaches. So, closing this as won't fix.\n" ]

[]

[]

[ "It looks like you're missing assigning your database to your model:\n\n``` python\ndb = SqliteDatabase('my_app.db')\n\nclass Player(Model):\n name = CharField()\n\n class Meta:\n database = db\n\ndb.create_tables([Player], True)\n```\n" ]

[]

[]

[ "The built-in async stuff all requires Python 3, and since Peewee supports both 2 and 3, any async will need to be implemented outside Peewee itself. I'd consider merging a `playhouse` extension, but as long as I'm still using Python 2 and `gevent`, I'm going to have trouble maintaining any 3.x-specific async code by myself.\n\nThere are some 3rd party libraries that implement async for Peewee, however:\n- [peewee-async](https://github.com/05bit/peewee-async)\n- [muffin-peewee](https://github.com/klen/muffin-peewee), integration with the async web framework [muffin](https://github.com/klen/muffin)\n\nHope that helps.\n", "Oh, I should add that psycopg2 does support async, so you can do something like this:\n\n``` python\nimport psycopg2\nfrom psycopg2 import extensions\n\nfrom gevent.socket import wait_read, wait_write\n\n\ndef monkey_patch():\n extensions.set_wait_callback(gevent_wait_callback)\n\n\ndef gevent_wait_callback(conn, timeout=None):\n while True:\n state = conn.poll()\n if state == extensions.POLL_OK:\n break\n elif state == extensions.POLL_READ:\n wait_read(conn.fileno(), timeout=timeout)\n elif state == extensions.POLL_WRITE:\n wait_write(conn.fileno(), timeout=timeout)\n else:\n raise psycopg2.OperationalError(\n\"Bad result from poll: %r\" % state)\n```\n", "@coleifer Ok, will make it an external extension for now. I did this with [peewee-momoko](https://github.com/txtadvice/peewee-momoko), but think it can be much improved with asyncpg and async /await.\n" ]

[]

[]

[ "You may find the following helpful: http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#test-utils\n\nBasically, at run-time you can swap out the database by setting `Model1._meta.database = test_db` and doing the same for `Model2`, etc. That's what the above helper takes care of (as well as schema creation).\n" ]

[]

[]

[]

[]

[]

[ "i know , thanks ! \n" ]

[]

[]

[ "Not sure what the purpose is for this change, can you explain?\n", "> Not sure what the purpose is for this change, can you explain?\n\nAllow to deal with `index_type` without the need of inheriting from `IndexedFieldMixin`.\nThe simpler, the better :)\n", "I appreciate the simplicity of this... let me think about it. Thanks!\n" ]

[]

[]

[ "OK, I found a bug in Peewee where the calls to commit and rollback weren't being wrapped in the exception wrapper that converts driver-specific exceptions into peewee exceptions. So that is fixed in 900ed22ee5505fa56565d52dc22cfbce496ec60f\n", "```\nOperationalError: cannot commit - no transaction is active\n```\n\nThis exception, with SqliteQueueDatabase, is what I tried to warn folks about when using this database class. If you try to use transactions in multiple threads at the same time, there is a risk of interleaving that will yield exactly this kind of error. For example:\n- t1: BEGIN\n- t1: INSERT\n- t2: BEGIN -- error, cannot start transaction within a transaction.\n\nOr the opposite:\n- t1: BEGIN;\n- t2: COMMIT;\n- t1: INSERT;\n- t1: COMMIT; -- error no transaction active.\n", "> I managed to get rid of all errors by using a thread lock for the main part of the code that writes to the database. It increases the run time but that's worth it. I leave it up to you to close this or investigate further.\n\nIf you're going to use the SqliteQueueDatabase, then you're responsible for managing your transactions such that these kinds of things don't happen. Because with the way it's designed to work, it's quite easy to shoot yourself in the foot. I strongly suggest reading the code to get an understanding for how it works. I also strongly suggest reading the isolation documentation on sqlite's website:\n\nhttp://sqlite.org/isolation.html\n\nThis will help you understand why things happen the way they do when you have multiple threads operating on a single database.\n", "You wrote in the other thread I shouldn't be using multi-statement transactions. Does that mean that without using db.atomic() this wouldn't happen? I read your code and tried to understand it. I generally try to do some research and experiments before bothering others (although it might seem otherwise ;-)) but I got nowhere. I tried to replicate my problems in an easier program but was unable to do so (probably because I don't understand it correctly).\n\nAnyway, thank you; I will do some reading. I never knew what I got into when I introduced a database in my tool...\n", "So the issue was this, as I understand it.\n\nEach database driver (sqlite3, pymysql, psycopg2, etc) implements all or most of the DB-API 2.0 spec (PEP-249). This PEP outlines a handful of exception types. What Peewee does is it _wraps_ the vendor-specific exception classes so that you only need to worry about catching the exceptions defined in Peewee itself. This allows portability between db implementations, e.g., I can catch `peewee.OperationalError` instead of having to catch `sqlite3.OperationalError` or `psycopg2.OperationalError`. Unfortunately, though, there was no exception wrapping taking place on the methods where Peewee was calling \"commit\" and \"rollback\" directly on the database driver. This meant that if you called commit and it triggered an OperationalError, you would get the \"vendor-specific\" version as opposed to the peewee version. **That** bug is what the above commit, 900ed22, fixes.\n", "Hm. I think I tried to catch the specific OperationalError and it didn't help. But doesn't matter, it seems to be mostly fixed by doing some locking and so on. Thanks for the help.\n", "> You wrote in the other thread I shouldn't be using multi-statement transactions. Does that mean that without using db.atomic() this wouldn't happen?\n\nThe raison d'être for `db.atomic()` is to allow multi-statement transactions. So, it would follow that this isn't going to play nicely with SqliteQueueDatabase. The reasons are described above, but have to do with the fact that behind-the-scenes there is only _one_ connection writing to the database despite there being the appearance of multiple concurrent writers. I feel like I've explained this numerous times, is there something that's unclear about how it works?\n", "No, I wanted to be sure I got it. Thanks for the patience ;-)\n" ]

[]

[]

[ "```\n+ if self.transaction_depth():\n+ raise Exception('Database.rollback() called while in a transaction (call transaction.rollback() instead).')\n self.get_conn().rollback()\n```\n\nI see the logic in what you're trying to do here, unfortunately I think this one boils down to user error as the docs are quite clear on showing the correct calling conventions.\n", "I agree, Peewee is well written and documented, and the right place to teach how to use it is the documentation, not raising exceptions.\n\nWhen I write code that I only will re-read, I never write documentation or comments, and if it's small no tests either. Instead I fill it up with `assert`s that will warn me when I will use it in the wrong way.\n\nI opened this issue just to give you some (hopefully constructive) feedback about something that for me wasn't intuitive and led me to a few bugs.\n", "I am playing with `SqliteQueueDatabase`, which doesn't play nice with transactions and which doesn't clearly say it in the documentation. \n\nThis is another case where I would use assert/exceptions to tell the developer that they are using transactions in the wrong way.\n\nWould that improve Peewee? No\n\nWould that help some distracted developer? Yes\n", "For one, there is a big fat warning on the SqliteQueueDatabase stating:\n\n> This is a new module and should be considered alpha-quality software \n\nFurthermore, I haven't even finished documenting the module. Or stabilized the API. \n", "> The db.rollback() from inside a transaction works, but does not automatically begin a new transaction\n\nI think this is as it should be. There is a separate method named `begin()`, so it seems quite confusing that the `Database.rollback` would also magically call `Database.begin()`.\n\nThis changes, however, when you move to using a transaction as a context manager or function decorator. In these cases, you're saying \"I want a transaction for the duration of the wrapped block\" -- if you happen to explicitly call commit or rollback on the transaction object, a new transaction begins to maintain the agreement about keeping the wrapped block atomic.\n" ]

[]

[]

[ "Looking at the code for the SQLiteQueueDatabase, I think I need to add some logic in there to close the connection. I'll get a patch up in a minute.\n", "Note: I can delete the file on linux but not in windows.\n", "I added the fix for that here: 72c5ea98209241f0fb3e2c1a330644735f803370\n\nBasically, each worker thread needed to be responsible for closing it's own connection, which wasn't happening. This should be fixed now.\n", "Thank you!\n", "Although this was a somewhat obscure problem in my case, if I can help only one developer not spend hours on trying to debug this issue... For future reference:\n\nI'm developing a flask app for which I have an automatic reloader enabled which restarts the web app every time a python file is changed (this is not enabled in production, of course). This forked the process (so that it can close the old one and restart it on change) which created a handle on the database file and locked it. That's why it could not be deleted. I started flask with the reloader disabled and voilà, the file could be deleted after closing the database. It worked on my linux test VM because there I have production code running where the reloader is disabled, but I was misled into thinking it could be an OS issue.\n\nI'll need to check how many of my database issues are caused by this because, as you quoted correctly, sqlite connections shouldn't be taken over into forks but I never thought of this reloader and of course I did all my tests with it enabled...\n\n\n" ]

[]

[]

[]

[]

[]

[ "You need to call `db.start()` before any queries are going to run.\n", "Doesn't change the outcome.\n", "Oh, your model isn't referencing your database. Duh.\n", "``` python\nclass TestModel(Model):\n test = CharField(null=True)\n\n class Meta:\n database = db\n```\n", "Oops, that what happens when you try to simplify your existing code to reproduce something. Sorry about that.\n" ]

[]

[]

[ "From the SQLite FAQ:\n\n> Under Unix, you should not carry an open SQLite database across a fork() system call into the child process.\n", "Thanks. But what if I initialize the database in the child process, not the parent process?\n", "Can you show more code, particularly:\n- How are you instantiating the database?\n- What database things happen before fork?\n- What database things happen after fork?\n", "Are you calling `db.start()` in the child process? Are you doing anything like creating tables before the fork? Are any connections (or implicit connections) created before the fork?\n", "You're right, I was not explicitly calling `db.start()` but instead using `autostart=True`. I thought that when initializing the database in the child process that would suffice. But apparently the SQLite instance is opened in the parent process but the database connection only made in the child process or something? You know that better than I do, but after disabling autostart and explicitly calling `db.start()` in the child process everything works fine.\n\nThanks so much! I'd be happy to send you a tip or a postcard or what not\n", "> But apparently the SQLite instance is opened in the parent process but the database connection only made in the child process or something?\n\nNo, that's not correct. I've started adding documentation for this new feature, which explains how all of this works:\n\nhttp://docs.peewee-orm.com/en/latest/peewee/playhouse.html#sqliteq\n\nIf, after reading, you still have questions about how this works feel free to respond on this ticket.\n", "> Thanks so much! I'd be happy to send you a tip or a postcard or what not\n\nThanks for the offer, the best thanks you can give me is to continue creating issues. In this case there wasn't a bug, technically, but I'm sure other people will have the same question and hopefully find our discussion.\n", "Alright, thanks again and I'll definitely open tickets when I have questions or found a bug that's actually one ;-)\n" ]

[]

[]

[ "Odd...that should work. The call to start() is needed (or initialize with autostart=True) because that sets up the worker threads which actually execute the queries. Also, the SqliteQueueDatabase sets the journal mode to wal automatically, but the query should work regardless. Are you using gevent? And when you say it doesn't work does it block forever without returning, time out, or return nothing? I'm afk otherwise I'd just check.\n", "It returns an `AsyncCursor`, but the `next()` of it returns `TypeError: 'NoneType' object is not subscriptable`.\n\nI don't use `gevent`. The 3 lines of code on my example are all it takes to reproduce in a clean new environment with peewee.\n\nI don't need it to work for me, I just reported because I noticed and it smelled funny.\n", "Aha, I see the issue. The call to `next()` is not forcing the cursor to wait for the worker thread to send back the results and fire off the event. Basically, it's using an API loophole.\n\nTry this:\n\n``` python\ndb.start() # You always need either this, or autostart=True.\nprint('journal mode = ', next(iter(db.execute_sql('pragma journal_mode')))[0]) # Note \"iter\"\n```\n\nFor performance reasons I would like to avoid checking the `Event` state every iteration (every call to next).\n", "I thought I had a solid understanding of python's iterator protocol, but the `next` builtin function kind of threw me off. I guess that it does not call it's argument's `__iter__()` method and directly calls `__next__()` instead. Not sure how to proceed at this point, as calling wait() every time a row is retrieved is going to make this slow as hell for large result sets.\n" ]

[]

[]

[ "Peewee is using `pymysql` under-the-hood (or `MySQLdb`, whichever you've got installed), so when you are querying the value using `pymysql` directly and not receiving anything that tells me that the issue is not with Peewee but somewhere else. Perhaps with `pymysql` though I'm not sure.\n", "I reported it to pymysql. I guess you are right, it should be fixed in pymysql, but it might make sense to also provide a work-around in peewee. Or at least, for now when this is not fixed, how would an easy work-around look like to use this in peewee? Basically doing `SELECT CAST(publish_date AS char) FROM pub`.\n", "The problem is that the `datetime` object does not allow something like `(2016, 0, 0)`. That's why pymysql currently failed to convert it and return it. It is possible to disable this conversation in pymysql, but then, I think peewee has the same problem. Currently, peewee will just pass through the string and not convert it properly. As far as I understand, something like `entry.publish_date.year` should normally work, but it does not for my case because `entry.publish_date` is a string. Do you consider that as a bug in peewee?\n", "Not at all a bug in peewee.\n" ]

[]

[]

[ "I find views to be in a bit of a gray area...kind of like triggers. My personal feeling is that there's enough variety in the types of SQL I'd need to support that until now peewee has avoided representing views or providing helpers to create/drop them. I think that for the time being I will continue to leave this unimplemented to focus on implementing and improving other features that may be more useful generally.\n" ]

[]

[]

[ "Peewee's JSON fields contain methods that wrap the Postgres operators:\n\nhttp://docs.peewee-orm.com/en/latest/peewee/playhouse.html#BinaryJSONField\n", "Have you tried this?\n\n```\nMyModel.jsonb_field.contains('the key')\n```\n", "I'd suggest that you could also use reduce to generate a list of clauses OR--ed or AND-ed together:\n\n```\nimport operator\nreduce(operator.and_, [MyModel.jsonb_field.contains(key) for key in keys])\n```\n", "Also:\n\nhttp://docs.peewee-orm.com/en/latest/peewee/querying.html#adding-user-defined-operators\n", "Awesome I haven't had a chance to go back through this code again but I think one of these will do the trick. Will reopen if I have any issues, thanks for your help!\n" ]

[]

[]

[ "This works in Python 2.x, Python 3.x I guess doesn't work the same way.\n" ]

[]

[]

[ "And — yes, I know about [`suppress()`](https://docs.python.org/3/library/contextlib.html#contextlib.suppress) from standard library, but it still makes impossible to do quick checks inline, like:\n\n``` python\nif obj.other_obj and obj.other_obj.foo == \"bar\":\n # yes, it is \"bar\"\n```\n", "> This looks good and seems to work, but PyCharm highlights this as reference to a non-existing field other_obj_id, so I basically lose a lot of useful IDE features when using this undeclared attribute.\n\nThis is really the de-facto way to do it. I'm sorry that PyCharm complains about it, the field is added dynamically. I would avoid using the foreign key directly as that can cause a query to be issued, which in most cases you don't want.\n", "Oh, you can also try this:\n\n``` python\nobj._data.get('foreign_key_name') is None\n```\n" ]

[]

[]

[]

[]

[]

[ "Peewee does not, to the extent that makes sense to me, do things that violate expectations or issue queries. If you think of the model instances as containers for row data, instead of stateful representations of query results, then I think you might be closer to what I intended the library to be. The general idea of issuing queries to get individual column values \"behind-the-scenes\" seems like the kind of magic I would rather avoid, because it can lead to very inefficient applications that appear to work. If you are explicitly selecting a sub-set of columns, presumably your application knows which columns are un-fetched and you could write a helper method to load those from the database yourself. That's the approach I'd take.\n", "@coleifer I understand the skepticism against additional magic. However, doesn't peewee already do behind-the-scenes magic with lazy-loading `ForeignKeys`? Having similar behavior for other fields is not very different from that.\n\nAlso, I wouldn't call it \"magic\" if we required user to call a method (`load_missing ()` and `ensure_fields (...)` in my example) to load up the remaining fields. To clarify, I don't really want lazy loading either, because it would generate unneeded SELECTs to the db. It's better when you have to explicitly call something.\n\nAs this is probably not very popular need, I'm fine with peewee not supporting lazy loading fields. However, would it be possible to allow detecting which fields were not populated from the DB? Yeah, I could attach this info myself during load-time, but it would be cleaner (and better for debugging) if I could just check this from the model instance directly. Is there a specific need why defaults get populated into `_data` while non-loaded fields without default value dont?\n", "Comparing this to the lazy-loading of foreign-keys isn't quite apples-to-apples. You can always add something like this to your base model class in your project:\n\n``` python\nclass BaseModel(Model):\n def refresh(self):\n return type(self).get(self._meta.primary_key == self._get_pk_value())\n```\n\n> would it be possible to allow detecting which fields were not populated from the DB\n\nAs I mentioned, since your application is controlling this, theoretically it should be known to your application which fields need to be reloaded.\n" ]

[]

[]

[ "This ticket is lacking in a lot of detail...What exactly is it that you're asking? The `get_or_create` method does not depend on an \"id\" field, but can work with any constraint. The method itself first attempts a \"get\" using the data provided. If this fails, then an attempt is made to create. If the create fails with an integrity error, then the `get` is retried. That's all there is to it.\n", "@coleifer please, explain why is it necessary to have an integrity check at get_or_create?\r\nMy use case: check an item by key. in case it doesn't exist - create new one. But know I need to provide all the fields, otherwise not null and other constains won't be met.\r\nI would like to provide them only in case there is no matchin by id field.\r\n\r\nBesides, current behavior with integrity check is not documented in API: http://docs.peewee-orm.com/en/latest/peewee/api.html. And I can't get how this integrity check is currently implemented. Please, at least provide some explanation of it at API.\r\n(btw, nice ORM! I am loving its simplicity)" ]

[]

[]

[ "Oh yeah, I can see the implementation has a bad unintended consequence if the columns are aliases. Can you tell me a bit more about your use case? Its after lunch and I'm having trouble thinking abstractly. Is there an analogy example using Twitter tables? (user / tweet one to many, users to users many to many)?\n", "``` python\nclass SMS(Model):\n sender = ForeignKey(User)\n\ntweets = Tweet.select().join(User).join(SMS)\n```\n\nNow there should be one row for every tweet and SMS combination. Before I could get both tweets and smses from the query results:\n\n```\ntweet (unique)\ntweet.user (often duplicated)\ntweet.user.sms (often duplicated)\n```\n\nThis isn't a great idea in practice, but we actually have a model where the `SMS` table usually only links to a `User` once.\n", "@coleifer have you had a chance to give this any thought yet?\n", "@jzelinskie -- do you work with @jakedt or has this issue arisen for you independently?\n", "Honestly this feels a bit like a code smell to me. The query you're executing seems very much like a hack. Why not query user and join on both tweet and SMS? Closing as this seems like an edge case that only applies to a particular kind of hack.\n" ]

[]

[]

[ "Had another query where _prefetch_ didn't return expected results as before.\n", "Can you give me something reproducible?\n", "I don't assume you need anything else from me after @alexlatchford's comment.\nDo you think you'll get to this soon?\n\nThanks heaps! ;-)\n", "Should be fixed in 1c237421eaf6d1ab66218e999baa41c1811c5fc2\n", "Brilliant thanks Charles!\n" ]

[]

[]

[ "As I can see, you don't want very much to support inheritance: #616\n\nWell, a unified way to override _any_ dependencies would be even better, because I also have some cases where one table depends on existence of another because of a manually-written (via `SQL()`) constraint, which `sort_models_topologically()` also is not aware of.\n", "I'm not sure how sensible it is to provide a way to override such a fundamental algorithm, but it might work to add an optional \"depends_on\" attribute to the model meta options, that would inform the sorting algorithm. What do you think?\n", "Yes, this would be a good solution.\n", "Hmm...the more I'm thinking about this the less it makes sense. If you have a preexisting schema, then it's not like you're going to be creating and dropping peewee tables all over the place. It seems more likely that you'd create your tables once in production, on top of the preexisting schema. Right?\n", "I don't really understand the question. Really.\n\nMy problem is that some tables should be created after other ones are already created. One example is when table B inherits table A. Another one is when table B has a non-trivial foreign key which refers to columns from table A. In both cases, table creation in wrong order will fail, because PostgreSQL won't know what table A is.\n\nIn production, I may already have table A, so yes, sometimes I don't have this problem at all. But when creating a new test environment, I still do need to create all the tables at once, in correct order.\n\nThere is a workaround, though, and I use it now:\n\n``` python\ndb.create_tables(tables1) # tables that don't depend on anything\ndb.create_tables(tables2) # tables that depend on tables from tables1\ndb.create_tables(tables3) # tables that depend on tables from tables1 or tables2\n```\n\nBut I don't like it very much because I have to split list of tables into these «levels» manually.\n", "The nontrivial constraint and test environment are good points. Reopening.\n", "Thank you!\nWhen will this be in the package installable through `pip`? Or, is it already there?\n", "Not on pip yet, but next release will be soon.. I'll shoot for within the next few days\n", "I decided to try it already and installed it:\n\n``` sh\nsudo -H pip3 install git+https://github.com/coleifer/peewee.git@master\n```\n\nBut the order of table creation still looks random and changes from run to run. What is wrong? Should I also somehow uninstall old speedups or something like that?\n", "If it is important, here's override for `create_table()` in my `BaseModel`. It automatically makes the new table inherited from the one referenced in `_meta.parent`.\n\n``` python\nclass BaseModel(Model):\n database = db\n parent = None\n\n @classmethod\n def table(cls) -> str:\n return cls._meta.schema + \".\" + cls._meta.db_table\n\n @classmethod\n def create_table(cls, fail_silently=False):\n with db.transaction() as transaction:\n try:\n super().create_table()\n if cls._meta.parent:\n db.execute_sql(\"alter table \"+cls.table()+\" inherit \"+cls._meta.parent.table())\n\n except peewee.ProgrammingError as e:\n transaction.rollback()\n\n if not fail_silently:\n raise e\n\n if not re.match(r'^relation \"\\S+\" already exists$', str(e).strip()):\n raise e\n```\n", "Sorry, it was a bug in my code.\n", "Mmm... I'm sorry again, but does it really work? The code doesn't make sense to me.\r\n\r\nHere you seem to call `dfs()` on models which _depend on current model_ (am I right?):\r\n\r\n```python\r\nfor foreign_key in model._meta.reverse_rel.values():\r\n dfs(foreign_key.model_class)\r\n```\r\n\r\nAnd then tou seem to call `dfs()` on models which _current model depends on_:\r\n\r\n```python\r\nif model._meta.depends_on:\r\n for dependency in model._meta.depends_on:\r\n dfs(dependency)\r\n```\r\n\r\nAnd it really seems to choose incorrect order of creation for my models.", "@coleifer, any news?", "Are you seeing errors in the ordering that is generated?", "I have seen. I'll try to write a minimal example of what I have in my project some day later, not right now, sorry. :-(\r\n\r\nWill I need to open a new issue then?", "Looks a lot like it's working right... 76eb220f9b1babc5d2cea85c406454b1f73f99d0", "@coleifer, here's what I tried right now:\r\n\r\n```python\r\nclass D(BaseModel):\r\n pass\r\n\r\nclass C(BaseModel):\r\n d = ForeignKeyField(D)\r\n\r\nclass B(BaseModel):\r\n c = ForeignKeyField(C)\r\n\r\nclass A(BaseModel):\r\n class Meta:\r\n depends_on = B,\r\n \r\n c = ForeignKeyField(C)\r\n\r\nmodels = [ D, C, B, A ]\r\n\r\nordered = list(models)\r\nfor pmodels in permutations(models):\r\n ordering = sort_models_topologically(pmodels)\r\n print(\", \".join(m._meta.model_class.__name__ for m in ordering))\r\n assert ordering == ordered\r\n```\r\n\r\nThis code sometimes successfully runs and prints a series of lines `D, C, B, A` but sometimes it crashes and prints `D, C, A, B`. Please try it multiple times, you'll see. At least, I see it with my Linux Mint 17.3 and Python 3.5.\r\n\r\nI am not sure if the anti-alphabetical order or my classes matters, but I couldn't get the fail when they were named alphabetically. Maybe just an accident, I don't know.\r\n\r\nThe relationships between these classes are pretty much relationships between some of real classes in my project, where Peewee is unable to choose correct order for creating tables. Would be cool to have this fixed, thank you in advance!", "I tried that code and it worked every time for me (tried 10K times in a loop) on both python 2.7 and python 3.5.", "Lucky you! :-)\r\n\r\nBack to [this question](https://github.com/coleifer/peewee/issues/1076#issuecomment-265161314), then: do I really understand everything incorrectly, doesn't that fragment of code even look strange?\r\n\r\nBTW, I tried my example not in a loop but by restarting the whole code again and again. Since dictionaries are involved, I suppose some ordering can change on run-to-run basis.", "Here, I added the same code I showed before into the unittest. It sometimes runs ok but sometimes fails. I'm not sure how can I make the test consistently failing since sets are involved in the function, so I think we have to run it multiple times manually before seeing that the ordering does not always work properly. Currently I see that it doesn't but I don't know how you should fix it.", "Please check this, it seems to fix the problem. By the way, I got rid of the `reversed(reversed())` style of the sorting process because it made harder to understand what's going on." ]

[]

[]

[ "Thanks! This looks great.\n" ]

[]

[]

[ "That's how sqlite auto increment work if it is not a primary key: https://www.sqlite.org/autoinc.html\n", "Except I would assume that 'id' is a primary key.\n", "I agree, but that depends on how the table was created. \n\nWhatever the case I think the problem here is on the sqlite side, not peewee.\n", "The table was created by peewee based on the model:\n\n```\npeewee will automatically add an auto-incrementing integer primary key field named id\n```\n\nhttp://docs.peewee-orm.com/en/latest/peewee/models.html\n", "That's how sqlite work:\n\n```\nsqlite> create table t (id integer primary key, f);\nsqlite> insert into t (f) values (100);\nsqlite> insert into t (f) values (200);\nsqlite> insert into t (f) values (300);\nsqlite> delete from t where f=300;\nsqlite> insert into t (f) values (400);\nsqlite> select * from t;\n1|100\n2|200\n3|400\nsqlite>\n```\n", "The peewee documentation explicitly states it uses an auto-incrementing primary key for the row id.\n\nBut from the sqlite documentation I understand that it depends where the AUTOINCREMENT keyword is used.\nEither way I would expect the same behaviour in sqlite and postgres when peewee creates these tables.\n", "Ok, I found a specific class in peewee's sqlite implementation that should provide this:\nhttps://github.com/coleifer/peewee/blob/master/playhouse/sqlite_ext.py#L92\nSo the id should be overridden to use this class in stead.\n", "As was noted, see the:\n\nhttp://docs.peewee-orm.com/en/latest/peewee/playhouse.html#PrimaryKeyAutoIncrementField\n" ]

[]

[]

[ "What database engine are you using?\n", "Just committed a test. I was not able to replicate this issue:\n\n``` diff\ncommit 39531323fd4d24cc4fc0c7039ef83936ec908bc7\nAuthor: Charles Leifer <[email protected]>\nDate: Tue Sep 20 17:31:09 2016 -0500\n\n Add test related to #1073. Unable to replicate.\n\ndiff --git a/playhouse/tests/test_models.py b/playhouse/tests/test_models.py\nindex fc0884b..80a7eac 100644\n--- a/playhouse/tests/test_models.py\n+++ b/playhouse/tests/test_models.py\n@@ -2280,3 +2280,31 @@ class TestDefaultDirtyBehavior(PeeweeTestCase):\n\n dm3_db = DM.get(DM.id == dm3.id)\n self.assertEqual(dm3_db.field, 4)\n+\n+\n+class TestFunctionCoerceRegression(PeeweeTestCase):\n+ def test_function_coerce(self):\n+ class M1(Model):\n+ data = IntegerField()\n+ class Meta:\n+ database = in_memory_db\n+\n+ class M2(Model):\n+ id = IntegerField()\n+ class Meta:\n+ database = in_memory_db\n+\n+ in_memory_db.create_tables([M1, M2])\n+\n+ for i in range(3):\n+ M1.create(data=i)\n+ M2.create(id=i + 1)\n+\n+ qm1 = M1.select(fn.GROUP_CONCAT(M1.data).coerce(False).alias('data'))\n+ qm2 = M2.select(fn.GROUP_CONCAT(M2.id).coerce(False).alias('ids'))\n+\n+ m1 = qm1.get()\n+ self.assertEqual(m1.data, '0,1,2')\n+\n+ m2 = qm2.get()\n+ self.assertEqual(m2.ids, '1,2,3')\n```\n", "Hi, I used SqliteDatabase(':memory:'), but it is the same for MySQLDatabase as well.\n\nI ran your test and it gives me the same error as before:\n\n``` python\n======================================================================\nERROR: test_function_coerce (bla.TestFunctionCoerceRegression)\n----------------------------------------------------------------------\nTraceback (most recent call last):\n File \"/data/d.gielow/projects-python/cronjobs/bla.py\", line 31, in test_function_coerce\n m1 = qm1.get()\n File \"/data/d.gielow/projects-python/cronjobs/env/local/lib/python2.7/site-packages/peewee.py\", line 3090, in get\n return next(clone.execute())\n File \"playhouse/_speedups.pyx\", line 216, in playhouse._speedups._QueryResultWrapper.__next__ (playhouse/_speedups.c:4430)\n File \"playhouse/_speedups.pyx\", line 200, in playhouse._speedups._QueryResultWrapper.iterate (playhouse/_speedups.c:4159)\n File \"playhouse/_speedups.pyx\", line 275, in playhouse._speedups._ModelQueryResultWrapper.process_row (playhouse/_speedups.c:5466)\n File \"playhouse/_speedups.pyx\", line 263, in playhouse._speedups._DictQueryResultWrapper._make_dict (playhouse/_speedups.c:5306)\n File \"/data/d.gielow/projects-python/cronjobs/env/local/lib/python2.7/site-packages/peewee.py\", line 962, in python_value\n return value if value is None else self.coerce(value)\nValueError: invalid literal for int() with base 10: '0,1,2'\n```\n", "Fixed it for real this time, thanks for the traceback.\n" ]

[]

[]

[ "Fixed! Thanks for the great ticket.\n", "Glad to be of service :)\n" ]

[]

[]

[ "Relevant commits:\n\nhttps://github.com/coleifer/peewee/compare/2.4.4...2.4.5\n", "Are you calling connect and close at the start and end of every request? Is the busy timeout suitably high to allow retrying queries? I've noticed that die to the way SQLite does its busy timeout, many queries sent at close to the same time will always retry at the same times.\n", "What I've found is that by adding a slight bit of jitter to the default busy handler you'll see a lot less operational errors...I should really submit a patch...\n", "I installed the 2.4.5, removed the method `SqliteDatabase.begin()` and it works.\n\nThe method was added in this [commit](https://github.com/coleifer/peewee/commit/623374855c8c5fe5cf6aa0717b50e2ad77fc877c).\n\nThe logged SQL while executing a burst of two calls shows SQL statements alternating from the two calls. With the `SqliteDatabase.begin()` the `UPDATE` from the first call succeeds, the one from the second call fails. Without it they both succeed.\n\nHere is an excerpt from the log with the 2.4.5. The first two lines of the log disappear after removing the `SqliteDatabase.begin()`.\n\n```\n('BEGIN DEFERRED', None)\n('BEGIN DEFERRED', None)\n('SELECT \"t1\".\"id\", ...\n('SELECT \"t1\".\"id\", ...\n('UPDATE \"cncprogrampart\" SET ...\n('UPDATE \"cncprogrampart\" SET ...\n--- crash ---\n```\n", "Sorry, I was busy doing my tests and didn't notice your questions.\n\nI don't think I am doing anything else than the `db = peewee.SqliteDatabase(path_name + '/doc.db', threadlocals=True)` when the app starts. After that I use CherryPy with its default settings. I think there are 10 threads sharing `db`.\n", "Okay, I think that may be the source of the issue. It is probably wise to connect when the request comes in, then clowhen the response goes out. I imagine cherrypy provides some kinds of hooks as this is common to most all frameworks.\n\nDocs: http://docs.peewee-orm.com/en/latest/peewee/database.html#adding-request-hooks\n", "I tried with the Flask code that you show in the documentation and I tried to do the same thing with CherryPy. Both the version crash with `SqliteDatabase.begin()`, they both work without it.\n\nYou can test both the version with the scripts below. You start the server, then you go to `http://127.0.0.1:8080/` for CherryPy and to `http://127.0.0.1:5000/` for Flask.\n\nOne second after showing the page, a burst of two requests will reach the server and the server will crash on the second request.\n\n**CherryPy**\n\n```\nimport cherrypy\nimport peewee\nimport time\nimport logging\n\nlogger = logging.getLogger('peewee')\nlogger.setLevel(logging.DEBUG)\nlogger.addHandler(logging.StreamHandler())\n\ndb = peewee.SqliteDatabase('test.db')\n\nclass PeeweeModel(peewee.Model):\n class Meta:\n database = db\n\nclass Table1(PeeweeModel):\n n = peewee.IntegerField()\n counter = peewee.IntegerField()\n\nTable1.drop_table(True)\nTable1.create_table(True)\nTable1.create(n=1, counter=0)\nTable1.create(n=2, counter=0)\n\nclass Root:\n\n @cherrypy.expose\n def index(self):\n cherrypy.log('index')\n return \"\"\"<!DOCTYPE HTML>\n<html>\n<head>\n<script>\nsetTimeout(function(){\nxhttp = new XMLHttpRequest();\nxhttp.open(\"GET\", \"increase?n=1\", true);\nxhttp.send();\nxhttp = new XMLHttpRequest();\nxhttp.open(\"GET\", \"increase?n=2\", true);\nxhttp.send();}, 2000);\n</script>\n</head>\n<body>\n<a href=\"result\">See result</a>\n</body>\n</html>\"\"\"\n\n @cherrypy.expose\n def increase(self, n):\n cherrypy.log('increase start')\n with db.transaction():\n record = Table1.get(Table1.n == int(n))\n time.sleep(0.5)\n record.counter += 1\n time.sleep(0.5)\n record.save()\n time.sleep(0.5)\n cherrypy.log('increase end')\n return 'OK'\n\n @cherrypy.expose\n def result(self):\n cherrypy.log('result')\n return '<br>'.join(['n={} counter={}\\n'.format(r.n, r.counter) for r in Table1.select()])\n\ndef connect():\n cherrypy.log('connect')\n db.connect()\n\ndef close():\n cherrypy.log('close')\n if not db.is_closed():\n db.close()\n\ncherrypy.engine.subscribe('before_request', connect)\ncherrypy.engine.subscribe('after_request', close)\ncherrypy.quickstart(Root())\n```\n\n**Flask**\n\n```\nimport flask\nimport peewee\nimport time\nimport logging\n\nlogger = logging.getLogger('peewee')\nlogger.setLevel(logging.DEBUG)\nlogger.addHandler(logging.StreamHandler())\n\ndb = peewee.SqliteDatabase('test.db')\napp = flask.Flask(__name__)\n\[email protected]_request\ndef _db_connect():\n app.logger.debug('connect')\n db.connect()\n\[email protected]_request\ndef _db_close(exc):\n app.logger.debug('close')\n if not db.is_closed():\n db.close()\n\nclass PeeweeModel(peewee.Model):\n class Meta:\n database = db\n\nclass Table1(PeeweeModel):\n n = peewee.IntegerField()\n counter = peewee.IntegerField()\n\nTable1.drop_table(True)\nTable1.create_table(True)\nTable1.create(n=1, counter=0)\nTable1.create(n=2, counter=0)\n\[email protected]('/')\ndef index():\n app.logger.debug('index')\n return \"\"\"<!DOCTYPE HTML>\n<html>\n<head>\n<script>\nsetTimeout(function(){\nxhttp = new XMLHttpRequest();\nxhttp.open(\"GET\", \"increase/1\", true);\nxhttp.send();\nxhttp = new XMLHttpRequest();\nxhttp.open(\"GET\", \"increase/2\", true);\nxhttp.send();}, 2000);\n</script>\n</head>\n<body>\n<a href=\"result\">See result</a>\n</body>\n</html>\"\"\"\n\[email protected]('/increase/<n>')\ndef increase(n):\n app.logger.debug('increase start')\n with db.transaction():\n record = Table1.get(Table1.n == int(n))\n time.sleep(0.5)\n record.counter += 1\n time.sleep(0.5)\n record.save()\n time.sleep(0.5)\n app.logger.debug('increase end')\n return 'OK'\n\[email protected]('/result')\ndef result():\n app.logger.debug('result')\n return '<br>'.join(['n={} counter={}\\n'.format(r.n, r.counter) for r in Table1.select()])\n\napp.run(threaded=True)\n```\n", "I have something awesome you can try...\n\nIt's currently only in master branch, but if you want to try it out it should solve your problem.\n\nIn the `playhouse.sqliteq` module is a class named `SqliteQueueDatabase`. Replace this:\n\n``` python\n\ndb = peewee.SqliteDatabase('test.db')\n```\n\nWith this:\n\n``` python\nfrom playhouse.sqliteq import SqliteQueueDatabase\ndb = SqliteQueueDatabase('t.db', readers=4, autostart=True)\n```\n\nAt the same time, remove all calls to db.connect() and db.close(). \n", "Another thing you should _always_ be doing is specifying `journal_mode='wal'` when you instantiate your Sqlite database. This allows multiple readers to co-exist with a single writer, and I think this may also magically solve your issues:\n\n``` python\ndb = SqliteDatabase('foo.db', pragmas=[('journal_mode', 'wal')])\n```\n", "Oh, and lastly, you can use the `PooledSqliteDatabase` from the `playhouse.pool` module. This will also most likely solve the issues you are encountering. You would write:\n\n``` python\nfrom playhouse.pool import PooledSqliteExtDatabase\n\ndb = PooledSqliteExtDatabase(\n 'foo.db', \n pragmas=[('journal_mode', 'wal')],\n max_connections=30,\n stale_timeout=3600,\n check_same_thread=False)\n```\n", "Thanks for suggesting to use the WAL journal mode.\n\nI tried your second and third suggestions, and unfortunately the magic didn't happen. \n\nI just cloned the Peewee repository. I never used git to clone one library used in another project. How do I tell my app to `import peewee` from the repository folder instead of using the one installed by pip? Do I need to uninstall it with pip and add the new path to the `PYTHONPATH`?\n\n(Going home now, see you tomorrow)\n", "You can run `import peewee` then on the next line just type `peewee` and press `<enter>`. It should print which module you're using. For example:\n\n\n", "Even awesome doesn't seem to be enough :(\n\nI did `pip uninstall peewee` and `import peewee` from the cloned repository.\n\nThe test with Flask now fails and the server doesn't start (see the traceback below).\n\nThe test with CherryPy runs, but crashes like the old one when the second call finds the database locked. I tried both with and without the `connect()` and `close()`.\n\n**Flask code**\n\n```\nimport flask\nimport time\nimport logging\nimport peewee\n\nlogger = logging.getLogger('peewee')\nlogger.setLevel(logging.DEBUG)\nlogger.addHandler(logging.StreamHandler())\n\n# db = peewee.SqliteDatabase('test.db', pragmas=[('journal_mode', 'wal')])\n\nfrom playhouse.sqliteq import SqliteQueueDatabase\ndb = SqliteQueueDatabase('test.db', readers=4, autostart=True)\n\napp = flask.Flask(__name__)\n\[email protected]_request\ndef _db_connect():\n app.logger.debug('connect')\n db.connect()\n\[email protected]_request\ndef _db_close(exc):\n app.logger.debug('close')\n if not db.is_closed():\n db.close()\n\nclass PeeweeModel(peewee.Model):\n class Meta:\n database = db\n\nclass Table1(PeeweeModel):\n n = peewee.IntegerField()\n counter = peewee.IntegerField()\n\nTable1.drop_table(True)\nTable1.create_table(True)\nTable1.create(n=1, counter=0)\nTable1.create(n=2, counter=0)\n\[email protected]('/')\ndef index():\n app.logger.debug('index')\n return \"\"\"<!DOCTYPE HTML>\n<html>\n<head>\n<script>\nsetTimeout(function(){\nxhttp = new XMLHttpRequest();\nxhttp.open(\"GET\", \"increase/1\", true);\nxhttp.send();\nxhttp = new XMLHttpRequest();\nxhttp.open(\"GET\", \"increase/2\", true);\nxhttp.send();}, 2000);\n</script>\n</head>\n<body>\n<a href=\"result\">See result</a>\n</body>\n</html>\"\"\"\n\[email protected]('/increase/<n>')\ndef increase(n):\n app.logger.debug('increase start')\n with db.transaction():\n record = Table1.get(Table1.n == int(n))\n time.sleep(0.5)\n record.counter += 1\n time.sleep(0.5)\n record.save()\n time.sleep(0.5)\n app.logger.debug('increase end')\n return 'OK'\n\[email protected]('/result')\ndef result():\n app.logger.debug('result')\n return '<br>'.join(['n={} counter={}\\n'.format(r.n, r.counter) for r in Table1.select()])\n\napp.run(threaded=True)\n```\n\n**Flask traceback**\n\n```\nTraceback (most recent call last):\n File \"C:\\eclipse\\plugins\\org.python.pydev_5.2.0.201608171824\\pysrc\\pydevd.py\", line 1531, in <module>\n globals = debugger.run(setup['file'], None, None, is_module)\n File \"C:\\eclipse\\plugins\\org.python.pydev_5.2.0.201608171824\\pysrc\\pydevd.py\", line 938, in run\n pydev_imports.execfile(file, globals, locals) # execute the script\n File \"C:\\eclipse\\plugins\\org.python.pydev_5.2.0.201608171824\\pysrc\\_pydev_imps\\_pydev_execfile.py\", line 25, in execfile\n exec(compile(contents+\"\\n\", file, 'exec'), glob, loc)\n File \"C:\\workspace\\test\\test_flask_peewee_burst.py\", line 36, in <module>\n Table1.drop_table(True)\n File \"C:\\workspace\\peewee\\peewee.py\", line 4904, in drop_table\n cls._meta.database.drop_table(cls, fail_silently, cascade)\n File \"C:\\workspace\\peewee\\peewee.py\", line 3804, in drop_table\n model_class, fail_silently, cascade))\n File \"C:\\workspace\\peewee\\playhouse\\sqliteq.py\", line 199, in execute_sql\n queue.put(cursor)\n File \"C:\\Anaconda3\\envs\\flask\\lib\\queue.py\", line 127, in put\n if self.maxsize > 0:\nTypeError: unorderable types: NoneType() > int()\n```\n", "What happens if I use the 2.4.4 (or if I delete the `SqliteDatabase.begin() from a more recent version`)?\n\nDo I risk that the statements inside a transaction are not really a transaction, even if I wrap them in a `db.transaction()`?\n\nOr...?\n", "Oh shit, python 3. I'll fix that.\n", "Why is this issue closed?\n\nThe fix mentioned above fixes a problem mentioned on [a comment](https://github.com/coleifer/peewee/issues/1071#issuecomment-248661857), not the original problem.\n\nI think this is an important problem and should be solved. I am just sending two requests faster than they can be processed and the database fails instead of waiting with the second one. I am surprised that nobody ever found this problem. Am I doing something so uncommon? Or am I doing it in the wrong way?\n\nI just realized that I was already using features introduced after the 2.4.4 (like `union_all(()`) and I can't go back to the latest working version. So I upgraded to the 2.8.3, did some (manual) testing and found a few places where the app either locks the database forever and the server needs to be restarted or it crashes complaining that the server is locked.\n\nI added the following monkey patch to both the development and production servers and everything seems to work fine, but... monkey patching?... I'm scared!:\n\n```\nimport peewee\ndel peewee.SqliteDatabase.begin\n```\n", "Whoops!\n", "OK, so I don't believe there is a bug here. In your example flask application I see that you've added calls to `time.sleep()`. I presume this is to force the application into attempting to open a write transaction while another write transaction is open. SQLite only allows one writer at a time, though, so yes -- you will get errors if you try to do this. If the DB comes back saying it's locked by another writer, `pysqlite` will retry the query up to a certain time limit (default is 5 seconds, I believe). Should it fail to get the lock in that time limit, you get an error.\n\nThis is the correct behavior.\n\nI'm not sure how you had your application set up previously, how you were managing connections (it sounds like you weren't), and how you were managing transactions. There are too many variables in there for me to guess as to why this appeared to work for you.\n\nWhen you use SQLite in a multi-threaded environment you need to take care of how you manage your transactions, simple as that. I would not recommend monkeypatching the begin method unless you want a subtly broken app, or an app that works by accident rather than design.\n\nSuggestions:\n- Use the `playhouse.sqliteq.SqliteQueueDatabase`. I've added some preliminary docs [here](http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#sqliteq).\n- Keep your write transactions as small as possible, so that they can run quickly and then get out of the way to allow the next writer to acquire the lock.\n- Avoid keeping a connection to the database open for a long time after writing.\n", "> If the DB comes back saying it's locked by another writer, pysqlite will retry the query up to a certain time limit (default is 5 seconds, I believe). Should it fail to get the lock in that time limit, you get an error.\n> \n> This is the correct behavior.\n\nI agree with you. You describe the behavior I would expect, which was the behavior until 2.4.4. If there was a write transaction in progress, the 2.4.4 would wait (up to the 5 seconds default timeout for sqlite) and then crash.\n\nNow it just crashes, without waiting.\n\nYour advice to make the transactions as small as possible and not to keep a transaction after writing is valid, but I can't shrink the time to zero. I can shorten the time and decrease the chance of crash, but can't get rid of it. The correct behavior would be for peewee to take care of it as it used to up to 2.4.4.\n\nI tried all the solutions you suggested, but no one does what you say.\n\nI cleaned my previous test so that now it's easier to follow. Requesting `localhost:5000` with the code below will send 3 requests at 0.1 seconds distance from each other:\n- The first request will read a record, change some values and write it back to the database\n- The second request will try to do the same and wait for the previous transaction to be finished\n- Same with the third, but will rollback after saving, just to test the rollback\n\nUsing peewee 2.4.4 the result is as expected: the second save will wait for the first transaction to be finished and the third will wait for the second. At the end the value in the database will be 2 because the 3 has been rollbacked.\n\nUsing peewee 2.8.5 with all the combination that I can think of I get one of these 3 wrong results: \n- Immediate crash without waiting for the sqlite timeout\n- Nothing is saved\n- The value 3 is saved (no rollback was performed on the third transaction)\n\nHere are the results of my tests:\n\n\nHere is the code:\n\n``` Python\nimport flask\nimport time\nimport logging\nimport peewee\nimport threading\nimport datetime\n\nCREATE_CONNECTIONS = 0\nUSE_SqliteDatabase = 0\nUSE_PooledSqliteExtDatabase = 0\nUSE_SqliteQueueDatabase = 1\nDEL_BEGIN = 0\n\nprint('peewee.__version__ =', peewee.__version__)\n\nif DEL_BEGIN:\n del peewee.SqliteDatabase.begin\n\nlogger = logging.getLogger('peewee')\nlogger.setLevel(logging.DEBUG)\nlogger.addHandler(logging.StreamHandler())\n\nif USE_SqliteDatabase:\n if peewee.__version__ == '2.4.4':\n db = peewee.SqliteDatabase('test.db')\n else:\n db = peewee.SqliteDatabase('test.db', pragmas=[('journal_mode', 'wal')])\nif USE_PooledSqliteExtDatabase:\n from playhouse.pool import PooledSqliteExtDatabase\n db = PooledSqliteExtDatabase(\n 'test.db',\n pragmas=[('journal_mode', 'wal')],\n max_connections=30,\n stale_timeout=3600,\n check_same_thread=False)\nelif USE_SqliteQueueDatabase:\n from playhouse.sqliteq import SqliteQueueDatabase\n db = SqliteQueueDatabase(\n 'test.db',\n pragmas=[('journal_mode', 'wal')],\n readers=4,\n autostart=True)\n\nclass PeeweeModel(peewee.Model):\n class Meta:\n database = db\n\nclass Table1(PeeweeModel):\n n = peewee.IntegerField()\n time_stamp = peewee.CharField(null=True)\n\nTable1.drop_table(True)\nTable1.create_table(True)\nTable1.create(n=0)\n\napp = flask.Flask(__name__)\n\[email protected]_request\ndef _db_connect():\n if CREATE_CONNECTIONS:\n log('connect')\n db.connect()\n\[email protected]_request\ndef _db_close(exc):\n if CREATE_CONNECTIONS:\n log('close')\n if not db.is_closed():\n db.close()\n\ndef now():\n return datetime.datetime.now().strftime('%H:%M:%S.%f')\n\ndef log(txt):\n print(' {} {:6d} {}'.format(now(),\n threading.current_thread().ident,\n txt))\n\[email protected]('/')\ndef index():\n log('index')\n return \"\"\"<!DOCTYPE HTML>\n<html>\n<head>\n<script>\nsetTimeout(function(){\n xhttp = new XMLHttpRequest();\n xhttp.open(\"GET\", \"set_time/1\", true);\n xhttp.send();\n}, 100);\n\nsetTimeout(function(){\n xhttp = new XMLHttpRequest();\n xhttp.open(\"GET\", \"set_time/2\", true);\n xhttp.send();\n}, 200);\n\nsetTimeout(function(){\n xhttp = new XMLHttpRequest();\n xhttp.open(\"GET\", \"set_time/3\", true);\n xhttp.send();\n}, 300);\n</script>\n</head>\n<body>\nhello\n</body>\n</html>\"\"\"\n\[email protected]('/set_time/<n>')\ndef set_time(n):\n with db.transaction():\n\n log(' {} set_time{} start transaction'.format(now(), n))\n time.sleep(1)\n\n log(' {} set_time{} get'.format(now(), n))\n rec = Table1.get()\n time.sleep(1)\n\n log(' {} set_time{} save'.format(now(), n))\n rec.n = n\n rec.time_stamp = now()\n rec.save()\n log(' {} set_time{} saved'.format(now(), n))\n time.sleep(1)\n\n if n == '3':\n db.rollback()\n log(' {} set_time{} rollback'.format(now(), n))\n log(' {} set_time{} end transaction'.format(now(), n))\n\n return 'OK'\n\napp.run(threaded=True)\n```\n", "This seems to be the commit that introduced the regression: https://github.com/coleifer/peewee/commit/623374855c8c5fe5cf6aa0717b50e2ad77fc877c\n\nAfter using `pip install -U git+git://github.com/coleifer/peewee@6f01097` it works.\n\nAfter using `pip install -U git+git://github.com/coleifer/peewee@6233748` it fails.\n", "The problem is here:\n\n```\nTable1.drop_table(True)\nTable1.create_table(True)\nTable1.create(n=0)\n```\n\nYou are implicitly creating a write transaction there, along with opening a connection and not closing it.\n\nChange that to read:\n\n``` python\n# If you're using something other than the SqliteQueueDatabase:\nwith db.execution_context():\n Table1.drop_table(True)\n Table1.create_table(True)\n Table1.create(n=0)\n\n# If you're using the SqliteQueueDatabase then just create the\n# tables after calling db.start()\n```\n", "It's also worth mentioning that SQLite's default transactions use `DEFERRED` semantics, so multiple transactions can be opened and reads performed concurrently, but depending on whether or not you're using WAL mode, one of the concurrent writes may fail.\n\nTo simplify your example, consider a view that does a compare-and-swap with a sleep in between. Something like:\n\n``` python\ndef my_view():\n with db.atomic():\n try:\n obj = Register.get(Register.value == 1)\n except Register.DoesNotExist:\n return 'cas failed, obj with value 1 not found'\n time.sleep(1)\n obj.value = 2\n obj.save()\n return 'cas succeeded'\n```\n\nIf you fire off two requests A and B, with B just a millisecond behind A, what you will see will depend on the type of transaction opened, and whether WAL mode is enabled.\n\n| lock type | wal mode? | result |\n| --- | --- | --- |\n| deferred | no | request A reports error because it cannot write due to B's read still being open. B succeeds. |\n| deferred | yes | A succeeds, B reports error when it tries to commit |\n| immediate | yes or no | A succeeds, B blocks until A finishes, then reports record not found |\n\ndeferred and not using WAL:\n- T0 = A opens read transaction. Finds object. Starts sleeping.\n- T1 = B opens read transaction. Finds object. Starts sleeping.\n- T1000 = A sets value and attempts UPDATE. A cannot aquire lock because B is still reading. Error.\n- T1001 = B acquires lock and updates successfully.\n\ndeferred and using WAL:\n- T0 = A opens read transaction. Finds object. Starts sleeping.\n- T1 = B opens read transaction. Finds object. Starts sleeping.\n- T1000 = A acquires write lock and saves successfully.\n- T1001 = B attempts to acquire write lock but cannot because A changed the DB snapshot. Error.\n\nimmediate with or without WAL:\n- T0 = A opens transaction. Finds object. Starts sleeping.\n- T1 = B attempts to open transaction, but A has lock. B waits.\n- T1000 = A saves successfully.\n- T1000.01~ = A released lock, B acquires lock. B cannot find object.\n", "I tried all the combinations of the 3 objects `SqliteDatabase`, `PooledSqliteExtDatabase` and `SqliteQueueDatabase`, with and without creation of the connection, with and without `db.start()`, with and without `with db.transaction():`. The results are the same: crash, no save or save but no rollback.\n\nI was never able to get it to correctly save and rollback when required (well, I was, by installing the good old 2.4.4)\n\nI just saw your last comment popping up. I will investigate the lock type and journal mode.\n\nI started using peewee and sqlite because it was easy and everything worked. Two months ago I started adding features to the old app, I upgraded many of the libraries, used some new feature (like `union_all(()`), then I received a few calls reporting crashes. I spent the last 10 days chasing this problem and trying to reduce it to a manageable test. (Sorry for the little venting, back to work now and thanks for your support.)\n", "The above examples I showed represent the true and correct semantics for a SQLite database, in my opinion. Have a look at https://www.sqlite.org/isolation.html for some more info.\n\nI want to highlight the example of using WAL mode with a DEFERRED transaction (the one where A succeeds and B reports an error). This happens because B is attempting to upgrade it's lock from a READ lock to a WRITE lock, but since A has swooped in and committed changes in the meantime, B's attempt to upgrade fails immediately.\n\nIt is described like this in the Sqlite docs:\n\n> Another example: X starts a read transaction using BEGIN and SELECT, then Y makes a changes to the database using UPDATE. Then X tries to make a change to the database using UPDATE. The attempt by X to escalate its transaction from a read transaction to a write transaction fails with an SQLITE_BUSY_SNAPSHOT error because the snapshot of the database being viewed by X is no longer the latest version of the database. If X were allowed to write, it would fork the history of the database file, which is something SQLite does not support. In order for X to write to the database, it must first release its snapshot (using ROLLBACK for example) then start a new transaction with a subsequent BEGIN.\n\nI hope this convinces you of the correctness of the implementation.\n\nSqliteQueueDatabase is a special-case in that since all queries are interleaved on a single connection, transactional semantics pretty much can be thrown out the window. It's intended for dead-simple or advanced use-cases, but not in-between I guess you might say.\n", "I understand your frustration. I now know more about SQLite than I ever thought I would need to, to write a useful tool. I think I misunderstood the problem you were encountering and offered you bad suggestions as a result, which didn't help you I'm sure, so I apologize for the \"red herrings\".\n", "The frustrating part is not lack of/bad support (which is always good quality and way more than what I pay for, thank you! :) )\n\nThe frustrating part is that I need to change code that has been working for two years. My code is broken now and... there is no regression. I could digest a non backward compatible change between 2.\\* and 3.0, but it's difficult to digest between 2.4.4 and 2.4.5. I guess incompatibility between versions can be part of the game, but this is my first time and it doesn't feel right.\n\nI still don't know why it was working before and I can't use it anymore in the same way, but after looking at my code it looks like I can work around the lack of `rollback()` and switch to `SqliteQueueDatabase`. Back to work now, thanks.\n", "Correct me if I'm wrong, but the fact is you've jumped from 2.4.4 (which is almost 2 years old at this point) to 2.8.5. So there's quite a lot of things that have changed besides just the decision to run SQLite in autocommit mode.\n\nIn the diff of version 2.4.4 to 2.4.5 you can see that [documentation](http://docs.peewee-orm.com/en/latest/peewee/database.html#sqlite-and-autocommit) was updated to reflect the [SQLite \"autocommit mode\" change](http://docs.peewee-orm.com/en/latest/peewee/database.html#sqlite-and-autocommit):\n\nhttps://github.com/coleifer/peewee/compare/2.4.4...2.4.5#diff-1fdd0c1e085be7d7af1cc4f80529eecdL133\n\n> The frustrating part is that I need to change code that has been working for two years\n\nI understand, believe me -- but can you explain to me precisely why the code worked in 2.4.4? What was happening at the connection level? What was happening at the transaction level?\n\nYou see, the thing is, pysqlite (`sqlite3` in the standard library) is sneaky. From the documentation:\n\n> By default, the sqlite3 module opens transactions implicitly before a Data Modification Language (DML) statement (i.e. INSERT/UPDATE/DELETE/REPLACE), and commits transactions implicitly before a non-DML, non-query statement (i. e. anything other than SELECT or the aforementioned).\n\nThis is one of the reasons Roger Binns created [apsw](https://github.com/rogerbinns/apsw). From the documentation to APSW (emphasis his):\n\n> **Nothing** happens behind your back. By default pysqlite tries to manage transactions by parsing your SQL for you, but you can turn it off. This can result in very unexpected behaviour with pysqlite.\n\nPeewee follows the same principles, and manages to use the standard library SQLite driver so users of Peewee don't have to install an additional dependency.\n", "Last week I tried to test the behavior with the different combinations of journal mode and isolation using `sqlite3` without `peewee`, but I noticed that something was added to the SQL statements that I was sending, so I gave up. The next time I will try with `apsw`.\n\nI don't know why my code was working and stopped. It was my first time with SQL, with peewee and with python in general, so I used all the defaults. I recreated a simplified version that reproduces the problem on a new clean environment with only peewee.\n\nThe code below works with the 2.4.4 and fails with the 2.4.5. Changing the value of `autocommit` makes no difference, all the transactions happen in a `with db.transaction()` block. \n\nI really appreciate you spending time on this issue, but I understand if you consider it a waste of time because it is an old problem. \n\n``` python\nimport peewee\nimport time\nimport datetime\nimport threading\nimport os\nimport logging\n\nlogger = logging.getLogger('peewee')\nlogger.setLevel(logging.DEBUG)\nlogger.addHandler(logging.StreamHandler())\n\nif os.path.exists('test.db'):\n os.unlink('test.db')\n\ndb = peewee.SqliteDatabase('test.db', autocommit=True)\n\nclass Table1(peewee.Model):\n n = peewee.IntegerField()\n time_stamp = peewee.CharField()\n class Meta:\n database = db\n\ndef now():\n return datetime.datetime.now().strftime('%H:%M:%S.%f')\n\ndef add_rec(n):\n with db.transaction():\n time.sleep(1)\n\n with db.transaction() as tx:\n rec = Table1.get()\n time.sleep(1)\n\n Table1.create(n=n, time_stamp=now())\n rec.save()\n time.sleep(1)\n\n if n == 3:\n tx.rollback()\n\nwith db.transaction():\n Table1.create_table(True)\n Table1.create(n=0, time_stamp=now())\n\nt1 = threading.Timer(0.3, add_rec, args=[1])\nt2 = threading.Timer(0.4, add_rec, args=[2])\nt3 = threading.Timer(0.5, add_rec, args=[3])\n\nt1.start()\nt2.start()\nt3.start()\n\nt1.join()\nt2.join()\nt3.join()\n\nfor rec in Table1.select():\n print(rec.id, rec.n, rec.time_stamp)\n```\n", "I spent two weeks trying to get it to work as it used to.\n\nMy old code does not specify `autocommit` (it defaults to `True`) and works `with transaction` blocks. So, according to the [documentation](http://docs.peewee-orm.com/en/latest/peewee/database.html#sqlite-and-autocommit), it should still work, but it doesn't.\n\nMy previous comment shows an example working with 2.4.4 and failing with later versions.\n\nI do understand why it fails (thanks for the explanation) and I don't understand why it was working. But it was working and now, after wasting two weeks, I'm still stuck, thinking how far I can go without transactions or if I should abandon either sqlite or peewee and restart with something else. Whatever option I chose will require me to change lots of code.\n\nIf you think that sqlite + multithreading should not allow the use of transactions and rollback, and the only way to go is `SqliteQueueDatabase`, then that's what I will try.\n\nIf you think that I should be able to use transactions with sqlite + multithreading, then I would appreciate an example of how to do it.\n", "I'd just like to clarify: **you can use SQLite with multiple threads in Python, with or without Peewee**. You only need to be aware of the fact that only one connection can write to the database at a time.\n\n> If you think that sqlite + multithreading should not allow the use of transactions and rollback, and the only way to go is SqliteQueueDatabase, then that's what I will try.\n\n**Not at all**.\n\nI **know** you can use transactions with SQLite and multithreading, because I am doing so myself on a handful of websites, services, and scripts.\n\nI had thought that when I was showing examples using \"compare-and-set\" that the solution was clear, but to re-cap: I believe you can get the \"old\" behavior by specifying \"immediate\" as the transaction type. \n\nIn Peewee 2.8.5, the version currently on PyPI, you would write:\n\n``` python\ndb = SqliteExtDatabase('/my/db')\n\nwith db.granular_transaction('immediate') as txn:\n blah blah\n```\n\nI've renamed this method in `master` to plain old \"transaction\", so if you're running on master or a version newer than 2.8.5, just use `transaction`:\n\n``` python\ndb = SqliteExtDatabase(...)\n\nwith db.transaction('immediate') as txn:\n blah blah\n```\n\nThe caveat here is that you need to be using the `playhouse.sqlite_ext.SqliteExtDatabase`, as this database class implements sqlite-specific features including specifying transaction type.\n\nThe other thing to note is that you cannot currently do a similar thing with `atomic()`. This is because only the outer-most transaction can declare a lock type, anything nested below that uses a savepoint.\n\n---\n\n> I don't understand why it was working\n\nI think this piece is crucial to your own feeling of confidence moving forward with whatever solution you end up choosing. I understand that it's complicated to try and figure out what's going on when you have multiple threads, connections, and pysqlite doing it's crazy magic, but it might be worth digging into in your spare time.\n" ]

[]

[]

[ "Currently ran into this. Would be awesome to see 1`INSERT IGNORE INTO` added for MySQL", "@coleifer what would need to happen to get this merged in. Would be willing to create new PR if needed.", "This should be working in 3.x. See:\r\n\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#Insert\r\n* http://docs.peewee-orm.com/en/latest/peewee/api.html#Model.replace" ]

[]

[]

[ "What do you get calling insert_many() with .upsert() as well?\n", "You mean `insert_many(stuff).upsert()`?\n", "Yeah, I was just away from my computer and wondered what that would output?\n", "Ah, yes. This works. Thanks a lot.\n" ]

[]

[]

[ "When it comes to using composite primary keys, things like save() break down a bit because peewee doesn't know what exactly to do since the previous primary key values are gone from the model instance. The way it should work is that it would update, setting the new values and using the old values as the where clause. But when you change them, the old values are gone so peewee freaks out.\n\nBut changing primary keys is kind of a sign that maybe you should consider a different primary key.\n", "I'm not editing for any real use-case, I'm just writing very generic software on top of peewee and noticed this behavior, which seemed weird to me - but it makes total sense now.\nI'll look for a way to either nicely assert from a Model class whether this will happen or simply implement an immutability flag for Models like this.\n\nThanks for the info so early in the morning. :)\n" ]

[]

[]

[ "OK . I find only `ignore` in [InsertQuery.on_conflict](http://docs.peeweeorm.com/en/latest/peewee/api.html#InsertQuery.on_conflict). But what is `INSERT OR IGNORE INTO` ? In Mysql only `INSERT IGNORE INTO` is right( I didn't use PostgreSQL or SQLite ). I think you should divide **peewee** into different versions for different DBMS and it can adapt to some features in different DBMS. \n\nI like **peewee** than **SQLAlchemy** because the former‘s document and api design are much more beautiful than the latter. I hope **peewee** become more perfect.\n", "At the moment the upsert/insert or replace code is a bit fragmented and poorly designed.\n\nHave you tried using the `upsert()` syntax, or could you share the insert statement you're executing along with the generated SQL?\n", "I create a pull request. I hope you can have a look.@coleifer\nhttps://github.com/coleifer/peewee/pull/1070\n", "I would like that upsert behaviour work with all databases. If this is too complex with sql support on specific databases, maybe with a fallback to create_or_get() then save()\r\nI'm getting db type from conf file at runtime. There is also peewee-mssql addition. For compability I'm doing create_or_get() then save(). It would be good to have upsert() work with optimized sql or fallback. Or if you have other advices?", "Hi, I am having the same issue. Any plans to get the PR merged? I am not much experienced with Python, but in case some help is needed to get this done, I can give a shot.\r\nThanks!", "> Have you tried using the `upsert()` syntax, or could you share the insert statement you're executing along with the generated SQL?\r\n\r\nThe big problem with `upsert()` in MySQL is that it generates a `REPLACE INTO` which deletes the matching rows and re-inserts them. If there is a foreign key to that row then those keys are taken into account (either cascading the delete or blocking the delete). However, an `INSERT INTO ... ON DUPLICATE KEY UPDATE` doesn't have this issue.", "As a workaround, I did the following:\r\n\r\n``` python\r\nclass CustomInsertQuery(InsertQuery):\r\n \"\"\" Custom implementation of peewee's InsertQuery that provides\r\n proper syntax for `IGNORE` inserts on MySQL.\r\n\r\n https://github.com/coleifer/peewee/issues/1067\r\n \"\"\"\r\n\r\n def sql(self):\r\n sql, params = super(CustomInsertQuery, self).sql()\r\n if sql.startswith('INSERT OR'):\r\n sql = sql.replace('INSERT OR', 'INSERT')\r\n return sql, params\r\n```\r\n\r\n``` python\r\nclass CustomBaseModel(Model):\r\n\r\n @classmethod\r\n def insert(cls, __data=None, **insert):\r\n fdict = __data or {}\r\n fdict.update([(cls._meta.fields[f], insert[f]) for f in insert])\r\n return CustomInsertQuery(cls, fdict)\r\n\r\n @classmethod\r\n def insert_many(cls, rows, validate_fields=True):\r\n return CustomInsertQuery(cls, rows=rows, validate_fields=validate_fields)\r\n```\r\n", "Please see new discussion thread in #1307 (which consolidates discussion of upsert functionality for sqlite/mysql/postgres)." ]

[]

[]

[]

[]

[]

[ "Issue with versions in my systems library and within the project.\n" ]

[]

[]

[ "Peewee does not currently support that column type. To add it, see the custom field docs:\n\nhttp://docs.peewee-orm.com/en/latest/peewee/models.html#custom-fields\n\nTo get pwiz to understand the field, you'll first need your field class, then you'll want to modify the `PostgresqlMetadata.column_map` mapping the OID to the new field type.\n" ]

[]

[]

[ "Wait...isn't this the whole point of connection pooling?\n", "Actually hold up, I see what you're talking about -- the issue isn't the pool, but the fact that peewee only holds a connection per thread.\n\nIf you need more than one connection (what is your use-case? I'm genuinely curious and not asking in an attempt to be patronizing), you can use the `ExecutionContext()`:\n\nhttp://docs.peewee-orm.com/en/latest/peewee/database.html#advanced-connection-management\n\n> Execution contexts allow finer-grained control over managing multiple connections to the database. When an execution context is initialized (either as a context manager or as a decorated function), a separate connection will be used for the duration of the wrapped block. You can also choose whether to wrap the block in a transaction.\n\nThere is already a mechanism in place for managing multiple conns per thread, so I will pass on this patch.\n\nLet me know if this is unclear.\n", "I think you've got the wrong end of the stick here. This patch fixes a connection leak which is unrecoverable, because you lose the reference unless you call `db.close_all()`.\n\nWhen you open 2 connections in a nested fashion (which we do accidentally, our fault) I'd assumed that because it was outside of an `ExecutionContext` block it would just do a noop on the second `db.connect()` and reuse the same connection as it's on the same thread. Unfortunately that doesn't happen and instead it draws another connection from the pool, overwriting the reference to the first in the `Database` instance (but it's still referenced in `db._in_use` so it cannot be garbage collected or closed).\n\nIf you repeat this the number of times you've set your `max_connections` to then you've exhausted your pool and your app starts throwing `ValueError(\"Max connections exceeded\")`.\n\nHope that makes some more sense.\n", "This has always been the behavior, though I agree that an accident in your code can have disproportionately bad consequences. I'm reluctant to change it because the method is a verb, and implies an action taking place. If you want to have the \"connect or re-use existing\" behavior, that is what the `Database.get_conn()` method is for.\n\nI can see an argument, however, for modifying the pool such that multiple calls to connect do not leak a connection. Reopening.\n", "Cool I've switched over our code to use `get_conn()`, I hadn't come across that one yet and looks like it'll do the job for what we're after actually. I agree that muddling the actionability isn't ideal so happy to close this and hopefully this PR can serve as documentation for those in the same unlikely situation in the future if they go googling.\n\nJust deployed this and looks like this solved our particular problem, thanks so much for your help!\n", "Maybe the only change I'd suggest out of this would be to change the docs for the Pool to use an example with `get_conn` to highlight this problem.\n" ]

[]

[]

[ "Joining on a subquery is totally easy in peewee, you just have to use the explicit form of the join predicate:\n\n``` python\nsubq = Service.select(fn.unnest(Service.ms).alias('code'))\nsubq = subq.alias('svc') # Subqueries need an alias.\nqs = (MedServ\n .select(MedServ.code, MedServ.name)\n .join(subq, on=(MedServ.code == subq.c.code)))\n```\n\nTo access a column inside the subquery we use the magical \"subq.c.code\". The \".c\" just allows us to create references to values inside the subquery.\n\nDoes that help?\n\nAnd no, peewee itself will not, but there are already at least one Peewee extension that provide asyncio. This one seems pretty popular:\n\nhttps://github.com/05bit/peewee-async\n", "Also, docs: http://docs.peewee-orm.com/en/latest/peewee/querying.html#using-subqueries\n", "> Does that help?\n\nYes, that's I need! Thanks!\nReally, yesterday I tired and forgot about `.c`\n\nI surprised about progress peewee-asyncio. Last time I saw the project it had 0.0.5 version :)\nWhat is the main difference between 2.8 and 3 branches of peewee?\n", "Closing as the issue seems resolved.\n\nDifferences: mostly around the SQL generation, but generally the goal is to have a more powerful sql generator. Also decoupling the returning of records from model instances\n" ]

[]

[]

[ "Also had to fix the unit test, as the unit test assumed that `654321` microseconds stored with a millisecond precision would come out as `654` microseconds instead of `654000` microseconds.\n" ]

[]

[]

[ "peewee is an activerecord ORM. Once you understand that, though, there are no surprises. An instance is a container for row values, but not a representation of the row itself in the sense that multiple instances with the same ID are somehow linked.\n\nDoes that help? And yes it is standard behavior. Django is the same.\n", "Please add a comment or create a new issue if you feel I haven't answered your question, or you are still not sure how this works.\n", "Ok for me, thank you :)\n" ]

[]

[]

[ "This is an issue:\n\n(Admin)\n\nA 1-item tuple needs a trailing comma. Try again and let me know.\n", "Have you been able to try your code with the change I suggested? This is the change:\n\n``` python\n def test_Admin(self):\n # v\n with test_database(test_db, (Admin,), create_tables=True):\n```\n", "I just saw your comment. About to try it now.\n", "It works now, thanks. \n", "I think I can make the code a little safer in the event of invalid input, so prod data doesn't get hurt. Very sorry an error wasn't raised.\n", "That's fine. Happy to contribute. \n", "A suggestion for the [docs](http://docs.peewee-orm.com/en/latest/peewee/playhouse.html#test-utils)\n\nMaybe change \n\n> models – a list of Model classes to use with the db\n\nto \n\n> models – a tuple of Model classes to use with the db\n\nOr add a note about the trailing comma for single element tuples. \n", "The trailing comma thing is just a part of Python, really. So beyond the scope of peewee that I'd feel compelled to add it anywhere a tuple is accepted, if I were going to start adding it here or there.\n", "Hopefully, that'll help until you find something safer\n" ]