GNU bug report logs - #67142
29.1; with-sqlite-transaction commits on exception rather than rolling back

Previous Next

To add a comment to this bug, you must first unarchive it, by sending
a message to control AT debbugs.gnu.org, with unarchive 67142 in the body.
You can then email your comments to 67142 AT debbugs.gnu.org in the normal way.

Toggle the display of automated, internal messages from the tracker.

Message #5 received at submit <at> debbugs.gnu.org (full text, mbox):

From: Vasilij Schneidermann <mail <at> vasilij.de>
To: bug-gnu-emacs <at> gnu.org
Subject: 29.1; with-sqlite-transaction commits on exception rather than
 rolling back
Date: Mon, 13 Nov 2023 01:47:01 +0100

[Message part 1 (text/plain, inline)]

During experimentation with built-in SQLite support, I've noticed that
if I use `with-sqlite-transaction' and there is a mistake in the body,
`sqlite-commit' is executed rather than `sqlite-rollback', thereby
committing the changes done up to the error instead of backing out.

This appears to be unusual behavior. From my quick research, the
following SQLite bindings in other languages have an equivalent to
`with-sqlite-transaction' and back out changes on error:

- CHICKEN Scheme:
  https://api.call-cc.org/5/doc/sql-de-lite#def:with-transaction
- Go: https://pkg.go.dev/database/sql#Conn.BeginTx
- Racket: https://docs.racket-lang.org/db/query-api.html#%28def._%28%28lib._db%2Fbase..rkt%29._call-with-transaction%29%29
- Ruby: https://www.rubydoc.info/gems/sqlite3/1.4.2/SQLite3/Database#transaction-instance_method
- Rust:
  https://docs.rs/rusqlite/latest/rusqlite/struct.Connection.html#method.transaction

In languages not offering an equivalent API, it was instead recommended
to manually issue BEGIN/COMMIT/ROLLBACK statements. But given that
`with-sqlite-transaction' exists, it would be less confusing to make it
back out on exception (and re-raise the original error).


In GNU Emacs 29.1 (build 1, x86_64-pc-linux-gnu, GTK+ Version 3.24.38,
cairo version 1.17.8)
Windowing system distributor 'The X.Org Foundation', version 11.0.12101009
System Description: Arch Linux

Configured using:
 'configure --sysconfdir=/etc --prefix=/usr --libexecdir=/usr/lib
 --with-tree-sitter --localstatedir=/var --with-cairo
 --disable-build-details --with-harfbuzz --with-libsystemd
 --with-modules --with-x-toolkit=gtk3 'CFLAGS=-march=x86-64
 -mtune=generic -O2 -pipe -fno-plt -fexceptions -Wp,-D_FORTIFY_SOURCE=2
 -Wformat -Werror=format-security -fstack-clash-protection
 -fcf-protection -g
 -ffile-prefix-map=/build/emacs/src=/usr/src/debug/emacs -flto=auto'
 'LDFLAGS=-Wl,-O1,--sort-common,--as-needed,-z,relro,-z,now -flto=auto''

Configured features:
ACL CAIRO DBUS FREETYPE GIF GLIB GMP GNUTLS GPM GSETTINGS HARFBUZZ JPEG
JSON LCMS2 LIBOTF LIBSYSTEMD LIBXML2 M17N_FLT MODULES NOTIFY INOTIFY
PDUMPER PNG RSVG SECCOMP SOUND SQLITE3 THREADS TIFF TOOLKIT_SCROLL_BARS
TREE_SITTER WEBP X11 XDBE XIM XINPUT2 XPM GTK3 ZLIB

Important settings:
  value of $LC_MESSAGES: 
  value of $LANG: en_US.UTF-8
  locale-coding-system: utf-8-unix

Major mode: Lisp Interaction

Minor modes in effect:
  tooltip-mode: t
  global-eldoc-mode: t
  eldoc-mode: t
  show-paren-mode: t
  electric-indent-mode: t
  mouse-wheel-mode: t
  tool-bar-mode: t
  menu-bar-mode: t
  file-name-shadow-mode: t
  global-font-lock-mode: t
  font-lock-mode: t
  blink-cursor-mode: t
  line-number-mode: t
  indent-tabs-mode: t
  transient-mark-mode: t
  auto-composition-mode: t
  auto-encryption-mode: t
  auto-compression-mode: t

Load-path shadows:
None found.

Features:
(shadow sort mail-extr emacsbug message mailcap yank-media puny dired
dired-loaddefs rfc822 mml mml-sec password-cache epa derived epg rfc6068
epg-config gnus-util text-property-search time-date subr-x mm-decode
mm-bodies mm-encode mail-parse rfc2231 mailabbrev gmm-utils mailheader
cl-loaddefs cl-lib sendmail rfc2047 rfc2045 ietf-drums mm-util
mail-prsvr mail-utils rmc iso-transl tooltip cconv eldoc paren electric
uniquify ediff-hook vc-hooks lisp-float-type elisp-mode mwheel
term/x-win x-win term/common-win x-dnd tool-bar dnd fontset image
regexp-opt fringe tabulated-list replace newcomment text-mode lisp-mode
prog-mode register page tab-bar menu-bar rfn-eshadow isearch easymenu
timer select scroll-bar mouse jit-lock font-lock syntax font-core
term/tty-colors frame minibuffer nadvice seq simple cl-generic
indonesian philippine cham georgian utf-8-lang misc-lang vietnamese
tibetan thai tai-viet lao korean japanese eucjp-ms cp51932 hebrew greek
romanian slovak czech european ethiopic indian cyrillic chinese
composite emoji-zwj charscript charprop case-table epa-hook
jka-cmpr-hook help abbrev obarray oclosure cl-preloaded button loaddefs
theme-loaddefs faces cus-face macroexp files window text-properties
overlay sha1 md5 base64 format env code-pages mule custom widget keymap
hashtable-print-readable backquote threads dbusbind inotify lcms2
dynamic-setting system-font-setting font-render-setting cairo
move-toolbar gtk x-toolkit xinput2 x multi-tty make-network-process
emacs)

Memory information:
((conses 16 36631 11549)
 (symbols 48 5153 0)
 (strings 32 13273 1917)
 (string-bytes 1 378652)
 (vectors 16 9346)
 (vector-slots 8 149327 16481)
 (floats 8 21 19)
 (intervals 56 235 0)
 (buffers 984 10))

[signature.asc (application/pgp-signature, inline)]

Message #8 received at 67142 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: Vasilij Schneidermann <mail <at> vasilij.de>
Cc: 67142 <at> debbugs.gnu.org
Subject: Re: bug#67142: 29.1;
 with-sqlite-transaction commits on exception rather than rolling back
Date: Thu, 16 Nov 2023 16:12:00 +0200

> Date: Mon, 13 Nov 2023 01:47:01 +0100
> From: Vasilij Schneidermann <mail <at> vasilij.de>
> 
> During experimentation with built-in SQLite support, I've noticed that
> if I use `with-sqlite-transaction' and there is a mistake in the body,
> `sqlite-commit' is executed rather than `sqlite-rollback', thereby
> committing the changes done up to the error instead of backing out.
> 
> This appears to be unusual behavior. From my quick research, the
> following SQLite bindings in other languages have an equivalent to
> `with-sqlite-transaction' and back out changes on error:

Thanks.

Does the change below look correct?  (I'm not an expert on SQLite or
DB programming in general.)

diff --git a/lisp/sqlite.el b/lisp/sqlite.el
index aad0aa4..df06647 100644
--- a/lisp/sqlite.el
+++ b/lisp/sqlite.el
@@ -24,7 +24,11 @@
 ;;; Code:
 
 (defmacro with-sqlite-transaction (db &rest body)
-  "Execute BODY while holding a transaction for DB."
+  "Execute BODY while holding a transaction for DB.
+If BODY completes normally, commit the changes and return
+the value of BODY.
+If BODY signals an error, or transaction commit fails, roll
+back the transaction changes."
   (declare (indent 1) (debug (form body)))
   (let ((db-var (gensym))
         (func-var (gensym)))
@@ -32,10 +36,13 @@ with-sqlite-transaction
            (,func-var (lambda () ,@body)))
        (if (sqlite-available-p)
            (unwind-protect
-               (progn
+               (let (result)
                  (sqlite-transaction ,db-var)
-                 (funcall ,func-var))
-             (sqlite-commit ,db-var))
+                 (setq result (funcall ,func-var))
+                 (or (sqlite-commit ,db-var)
+                     (signal 'sqlite-error (list "SQLite commit failed")))
+                 result)
+             (sqlite-rollback ,db-var))
          (funcall ,func-var)))))
 
 (provide 'sqlite)

Message #11 received at 67142 <at> debbugs.gnu.org (full text, mbox):

From: Vasilij Schneidermann <mail <at> vasilij.de>
To: Eli Zaretskii <eliz <at> gnu.org>
Cc: 67142 <at> debbugs.gnu.org
Subject: Re: bug#67142: 29.1; with-sqlite-transaction commits on exception
 rather than rolling back
Date: Thu, 16 Nov 2023 21:25:53 +0100

[Message part 1 (text/plain, inline)]

> Does the change below look correct?  (I'm not an expert on SQLite or
> DB programming in general.)

The `unwind-protect` part does not look correct since the rollback is
always performed, even after the body form completed successfully and a
commit was done. Either a commit or a rollback should be done, not both.
Perhaps `condition-case` would be the better option, but then the error
would need to be re-raised after doing the rollback...

A minor mistake is the result variable not using an uninterned symbol
(or alternatively, `prog1` could replace the use of the result variable).

[signature.asc (application/pgp-signature, inline)]

Message #14 received at 67142 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: Vasilij Schneidermann <mail <at> vasilij.de>
Cc: 67142 <at> debbugs.gnu.org
Subject: Re: bug#67142: 29.1; with-sqlite-transaction commits on exception
 rather than rolling back
Date: Fri, 17 Nov 2023 09:48:41 +0200

> Date: Thu, 16 Nov 2023 21:25:53 +0100
> From: Vasilij Schneidermann <mail <at> vasilij.de>
> Cc: 67142 <at> debbugs.gnu.org
> 
> > Does the change below look correct?  (I'm not an expert on SQLite or
> > DB programming in general.)
> 
> The `unwind-protect` part does not look correct since the rollback is
> always performed, even after the body form completed successfully and a
> commit was done. Either a commit or a rollback should be done, not both.

Oops.  Is the below better?

> A minor mistake is the result variable not using an uninterned symbol
> (or alternatively, `prog1` could replace the use of the result variable).

I don't understand this part, sorry.  Why do we need a symbol to
return the result of the body?

diff --git a/lisp/sqlite.el b/lisp/sqlite.el
index aad0aa4..4488896 100644
--- a/lisp/sqlite.el
+++ b/lisp/sqlite.el
@@ -24,18 +24,25 @@
 ;;; Code:
 
 (defmacro with-sqlite-transaction (db &rest body)
-  "Execute BODY while holding a transaction for DB."
+  "Execute BODY while holding a transaction for DB.
+If BODY completes normally, commit the changes and return
+the value of BODY.
+If BODY signals an error, or transaction commit fails, roll
+back the transaction changes."
   (declare (indent 1) (debug (form body)))
   (let ((db-var (gensym))
         (func-var (gensym)))
     `(let ((,db-var ,db)
            (,func-var (lambda () ,@body)))
        (if (sqlite-available-p)
-           (unwind-protect
-               (progn
-                 (sqlite-transaction ,db-var)
-                 (funcall ,func-var))
-             (sqlite-commit ,db-var))
+           (let (result commit)
+             (unwind-protect
+                 (progn
+                   (sqlite-transaction ,db-var)
+                   (setq result (funcall ,func-var))
+                   (setq commit (sqlite-commit ,db-var))
+                   result)
+             (or commit (sqlite-rollback ,db-var))))
          (funcall ,func-var)))))
 
 (provide 'sqlite)

Message #17 received at 67142 <at> debbugs.gnu.org (full text, mbox):

From: Visuwesh <visuweshm <at> gmail.com>
To: Eli Zaretskii <eliz <at> gnu.org>
Cc: 67142 <at> debbugs.gnu.org, Vasilij Schneidermann <mail <at> vasilij.de>
Subject: Re: bug#67142: 29.1; with-sqlite-transaction commits on exception
 rather than rolling back
Date: Fri, 17 Nov 2023 14:08:05 +0530

[வெள்ளி நவம்பர் 17, 2023] Eli Zaretskii wrote:

>> A minor mistake is the result variable not using an uninterned symbol
>> (or alternatively, `prog1` could replace the use of the result variable).
>
> I don't understand this part, sorry.  Why do we need a symbol to
> return the result of the body?

db-var and func-var are uninterned symbols in the macro expansion but
the variables 'result' and 'commit' marked below aren't.  If the intent
is not to expose these variables to the macro's BODY, the inner let
should also uninterned symbols right?

> diff --git a/lisp/sqlite.el b/lisp/sqlite.el
> index aad0aa4..4488896 100644
> --- a/lisp/sqlite.el
> +++ b/lisp/sqlite.el
> @@ -24,18 +24,25 @@
>  ;;; Code:
>  
>  (defmacro with-sqlite-transaction (db &rest body)
> -  "Execute BODY while holding a transaction for DB."
> +  "Execute BODY while holding a transaction for DB.
> +If BODY completes normally, commit the changes and return
> +the value of BODY.
> +If BODY signals an error, or transaction commit fails, roll
> +back the transaction changes."
>    (declare (indent 1) (debug (form body)))
>    (let ((db-var (gensym))
>          (func-var (gensym)))
>      `(let ((,db-var ,db)
>             (,func-var (lambda () ,@body)))
               --------


>         (if (sqlite-available-p)
> -           (unwind-protect
> -               (progn
> -                 (sqlite-transaction ,db-var)
> -                 (funcall ,func-var))
> -             (sqlite-commit ,db-var))
> +           (let (result commit)
                    ^^^^^^^^^^^^^
                    Use uninterned symbols here like above (marked with -).


> +             (unwind-protect
> +                 (progn
> +                   (sqlite-transaction ,db-var)
> +                   (setq result (funcall ,func-var))
> +                   (setq commit (sqlite-commit ,db-var))
> +                   result)
> +             (or commit (sqlite-rollback ,db-var))))
>           (funcall ,func-var)))))
>  
>  (provide 'sqlite)

Message #20 received at 67142 <at> debbugs.gnu.org (full text, mbox):

From: Vasilij Schneidermann <mail <at> vasilij.de>
To: Visuwesh <visuweshm <at> gmail.com>
Cc: Eli Zaretskii <eliz <at> gnu.org>, 67142 <at> debbugs.gnu.org
Subject: Re: bug#67142: 29.1; with-sqlite-transaction commits on exception
 rather than rolling back
Date: Fri, 17 Nov 2023 10:08:36 +0100

[Message part 1 (text/plain, inline)]

> > I don't understand this part, sorry.  Why do we need a symbol to
> > return the result of the body?
> 
> db-var and func-var are uninterned symbols in the macro expansion but
> the variables 'result' and 'commit' marked below aren't.  If the intent
> is not to expose these variables to the macro's BODY, the inner let
> should also uninterned symbols right?

Correct, this is what I was hinting at. As annoying as it is, when
writing unhygienic macros one should use uninterned symbols to avoid
exposing additional variables to the BODY argument.

Alternatively, the pattern of `(let ((return (...))) ... return)` can be
replaced with `(prog1 (...) ...)`.

@Eli: The new patch looks better and closer to how the issue is solved
in the Ruby sqlite3 gem. I'm still not sure about this use of
`unwind-protect` being correct, but it does preserve the backtrace in
case of an error better than when I used `(condition-case e (...) (error
(apply #'signal e)))`.

[signature.asc (application/pgp-signature, inline)]

Message #23 received at 67142 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: Vasilij Schneidermann <mail <at> vasilij.de>
Cc: 67142 <at> debbugs.gnu.org, visuweshm <at> gmail.com
Subject: Re: bug#67142: 29.1; with-sqlite-transaction commits on exception
 rather than rolling back
Date: Sat, 18 Nov 2023 12:37:41 +0200

> Date: Fri, 17 Nov 2023 10:08:36 +0100
> From: Vasilij Schneidermann <mail <at> vasilij.de>
> Cc: Eli Zaretskii <eliz <at> gnu.org>, 67142 <at> debbugs.gnu.org
> 
> > db-var and func-var are uninterned symbols in the macro expansion but
> > the variables 'result' and 'commit' marked below aren't.  If the intent
> > is not to expose these variables to the macro's BODY, the inner let
> > should also uninterned symbols right?
> 
> Correct, this is what I was hinting at. As annoying as it is, when
> writing unhygienic macros one should use uninterned symbols to avoid
> exposing additional variables to the BODY argument.
> 
> Alternatively, the pattern of `(let ((return (...))) ... return)` can be
> replaced with `(prog1 (...) ...)`.
> 
> @Eli: The new patch looks better and closer to how the issue is solved
> in the Ruby sqlite3 gem. I'm still not sure about this use of
> `unwind-protect` being correct, but it does preserve the backtrace in
> case of an error better than when I used `(condition-case e (...) (error
> (apply #'signal e)))`.

OK, how about the below?

diff --git a/lisp/sqlite.el b/lisp/sqlite.el
index aad0aa4..8a52573 100644
--- a/lisp/sqlite.el
+++ b/lisp/sqlite.el
@@ -24,19 +24,28 @@
 ;;; Code:
 
 (defmacro with-sqlite-transaction (db &rest body)
-  "Execute BODY while holding a transaction for DB."
+  "Execute BODY while holding a transaction for DB.
+If BODY completes normally, commit the changes and return
+the value of BODY.
+If BODY signals an error, or transaction commit fails, roll
+back the transaction changes."
   (declare (indent 1) (debug (form body)))
   (let ((db-var (gensym))
-        (func-var (gensym)))
+        (func-var (gensym))
+        (res-var (gensym))
+        (commit-var (gensym)))
     `(let ((,db-var ,db)
-           (,func-var (lambda () ,@body)))
+           (,func-var (lambda () ,@body))
+           ,res-var ,commit-var)
        (if (sqlite-available-p)
            (unwind-protect
                (progn
                  (sqlite-transaction ,db-var)
-                 (funcall ,func-var))
-             (sqlite-commit ,db-var))
-         (funcall ,func-var)))))
+                 (setq ,res-var (funcall ,func-var))
+                 (setq ,commit-var (sqlite-commit ,db-var))
+                 ,res-var)
+             (or ,commit-var (sqlite-rollback ,db-var))))
+         (funcall ,func-var))))
 
 (provide 'sqlite)
 

Message #26 received at 67142 <at> debbugs.gnu.org (full text, mbox):

From: Vasilij Schneidermann <mail <at> vasilij.de>
To: Eli Zaretskii <eliz <at> gnu.org>
Cc: 67142 <at> debbugs.gnu.org, visuweshm <at> gmail.com
Subject: Re: bug#67142: 29.1; with-sqlite-transaction commits on exception
 rather than rolling back
Date: Mon, 20 Nov 2023 22:14:00 +0100

[Message part 1 (text/plain, inline)]

> OK, how about the below?
> 
> diff --git a/lisp/sqlite.el b/lisp/sqlite.el
> index aad0aa4..8a52573 100644
> --- a/lisp/sqlite.el
> +++ b/lisp/sqlite.el
> @@ -24,19 +24,28 @@
>  ;;; Code:
>  
>  (defmacro with-sqlite-transaction (db &rest body)
> -  "Execute BODY while holding a transaction for DB."
> +  "Execute BODY while holding a transaction for DB.
> +If BODY completes normally, commit the changes and return
> +the value of BODY.
> +If BODY signals an error, or transaction commit fails, roll
> +back the transaction changes."
>    (declare (indent 1) (debug (form body)))
>    (let ((db-var (gensym))
> -        (func-var (gensym)))
> +        (func-var (gensym))
> +        (res-var (gensym))
> +        (commit-var (gensym)))
>      `(let ((,db-var ,db)
> -           (,func-var (lambda () ,@body)))
> +           (,func-var (lambda () ,@body))
> +           ,res-var ,commit-var)
>         (if (sqlite-available-p)
>             (unwind-protect
>                 (progn
>                   (sqlite-transaction ,db-var)
> -                 (funcall ,func-var))
> -             (sqlite-commit ,db-var))
> -         (funcall ,func-var)))))
> +                 (setq ,res-var (funcall ,func-var))
> +                 (setq ,commit-var (sqlite-commit ,db-var))
> +                 ,res-var)
> +             (or ,commit-var (sqlite-rollback ,db-var))))
> +         (funcall ,func-var))))
>  
>  (provide 'sqlite)

Thank you, this looks very good. I've tested it on my own code using the
SQLite support and there don't appear to be any (obvious issues).

[signature.asc (application/pgp-signature, inline)]

Message #31 received at 67142-done <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: Vasilij Schneidermann <mail <at> vasilij.de>
Cc: 67142-done <at> debbugs.gnu.org, visuweshm <at> gmail.com
Subject: Re: bug#67142: 29.1; with-sqlite-transaction commits on exception
 rather than rolling back
Date: Tue, 21 Nov 2023 15:39:52 +0200

> Date: Mon, 20 Nov 2023 22:14:00 +0100
> From: Vasilij Schneidermann <mail <at> vasilij.de>
> Cc: visuweshm <at> gmail.com, 67142 <at> debbugs.gnu.org
> 
> Thank you, this looks very good. I've tested it on my own code using the
> SQLite support and there don't appear to be any (obvious issues).

Thanks for testing and for the valuable feedback, I've now installed
this on the emacs-29 branch, and I'm therefore closing this bug.

Message #38 received at 67142 <at> debbugs.gnu.org (full text, mbox):

From: "J.P." <jp <at> neverwas.me>
To: Vasilij Schneidermann <mail <at> vasilij.de>
Cc: Eli Zaretskii <eliz <at> gnu.org>, visuweshm <at> gmail.com, 67142 <at> debbugs.gnu.org
Subject: Re: bug#67142: 29.1; with-sqlite-transaction commits on exception
 rather than rolling back
Date: Sun, 03 Mar 2024 06:04:48 -0800

Vasilij Schneidermann <mail <at> vasilij.de> writes:

>> OK, how about the below?
>> 
>> diff --git a/lisp/sqlite.el b/lisp/sqlite.el
>> index aad0aa4..8a52573 100644
>> --- a/lisp/sqlite.el
>> +++ b/lisp/sqlite.el
>> @@ -24,19 +24,28 @@
>>  ;;; Code:
>>  
>>  (defmacro with-sqlite-transaction (db &rest body)
>> -  "Execute BODY while holding a transaction for DB."
>> +  "Execute BODY while holding a transaction for DB.
>> +If BODY completes normally, commit the changes and return
>> +the value of BODY.
>> +If BODY signals an error, or transaction commit fails, roll
>> +back the transaction changes."
>>    (declare (indent 1) (debug (form body)))
>>    (let ((db-var (gensym))
>> -        (func-var (gensym)))
>> +        (func-var (gensym))
>> +        (res-var (gensym))
>> +        (commit-var (gensym)))
>>      `(let ((,db-var ,db)
>> -           (,func-var (lambda () ,@body)))
>> +           (,func-var (lambda () ,@body))
>> +           ,res-var ,commit-var)
>>         (if (sqlite-available-p)
>>             (unwind-protect
>>                 (progn
>>                   (sqlite-transaction ,db-var)
>> -                 (funcall ,func-var))
>> -             (sqlite-commit ,db-var))
>> -         (funcall ,func-var)))))
>> +                 (setq ,res-var (funcall ,func-var))
>> +                 (setq ,commit-var (sqlite-commit ,db-var))
>> +                 ,res-var)
>> +             (or ,commit-var (sqlite-rollback ,db-var))))
>> +         (funcall ,func-var))))
>>  
>>  (provide 'sqlite)
>
> Thank you, this looks very good. I've tested it on my own code using the
> SQLite support and there don't appear to be any (obvious issues).

Not obvious on account of the indentation, but it seems the second

  (funcall ,func-var)

snuck outside the `if' form with that fix, making body run twice if you
have SQLite.

Message #41 received at 67142 <at> debbugs.gnu.org (full text, mbox):

From: "J.P." <jp <at> neverwas.me>
To: 67142 <at> debbugs.gnu.org
Cc: eliz <at> gnu.org, mail <at> vasilij.de, visuweshm <at> gmail.com
Subject: Re: bug#67142: 29.1; with-sqlite-transaction commits on exception
 rather than rolling back
Date: Sun, 10 Mar 2024 20:43:04 -0700

[Message part 1 (text/plain, inline)]

"J.P." <jp <at> neverwas.me> writes:

> Not obvious on account of the indentation, but it seems the second
>
>   (funcall ,func-var)
>
> snuck outside the `if' form with that fix, making body run twice if you
> have SQLite.

I guess folks are too busy to get excited about fixing this. Here's a
patch in case that ever changes. Thanks.

[0001-Run-successful-body-once-in-with-sqlite-transaction.patch (text/x-patch, attachment)]

Message #44 received at 67142 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: "J.P." <jp <at> neverwas.me>
Cc: visuweshm <at> gmail.com, mail <at> vasilij.de, 67142 <at> debbugs.gnu.org
Subject: Re: bug#67142: 29.1; with-sqlite-transaction commits on exception
 rather than rolling back
Date: Mon, 11 Mar 2024 15:25:11 +0200

> From: "J.P." <jp <at> neverwas.me>
> Cc: eliz <at> gnu.org, visuweshm <at> gmail.com, mail <at> vasilij.de
> Date: Sun, 10 Mar 2024 20:43:04 -0700
> 
> "J.P." <jp <at> neverwas.me> writes:
> 
> > Not obvious on account of the indentation, but it seems the second
> >
> >   (funcall ,func-var)
> >
> > snuck outside the `if' form with that fix, making body run twice if you
> > have SQLite.
> 
> I guess folks are too busy to get excited about fixing this. Here's a
> patch in case that ever changes. Thanks.

Thanks, installed on the emacs-29 branch.

Previous Next

GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997,2003 nCipher Corporation Ltd, 1994-97 Ian Jackson.