From 3ad14cb8e5fd20c4cc138d2a1f94a69d396561dd Mon Sep 17 00:00:00 2001
From: Elvis Pranskevichus <elvis@edgedb.com>
Date: Wed, 29 Jan 2025 15:14:14 -0800
Subject: [PATCH] Expose `default_transaction_...` Postgres settings

This exposes the `default_transaction_isolation`,
`default_transaction_deferrable` and `default_transaction_read_only` (as
`default_transaction_access_mode`) settings.
---
 edb/buildmeta.py   |  2 +-
 edb/ir/statypes.py | 51 ++++++++++++++++++++++++++++++++++++++++++++++
 edb/lib/cfg.edgeql | 41 +++++++++++++++++++++++++++++++++++++
 edb/lib/sys.edgeql |  8 ++++++++
 4 files changed, 101 insertions(+), 1 deletion(-)

diff --git a/edb/buildmeta.py b/edb/buildmeta.py
index 6b8f53ab59cf..96825e6ff98a 100644
--- a/edb/buildmeta.py
+++ b/edb/buildmeta.py
@@ -60,7 +60,7 @@
 # The merge conflict there is a nice reminder that you probably need
 # to write a patch in edb/pgsql/patches.py, and then you should preserve
 # the old value.
-EDGEDB_CATALOG_VERSION = 2024_01_28_00_00
+EDGEDB_CATALOG_VERSION = 2024_01_29_00_00
 EDGEDB_MAJOR_VERSION = 7
 
 
diff --git a/edb/ir/statypes.py b/edb/ir/statypes.py
index e047eb2a4727..5c047080d32b 100644
--- a/edb/ir/statypes.py
+++ b/edb/ir/statypes.py
@@ -733,3 +733,54 @@ def get_translation_map(cls) -> Mapping[EnabledDisabledEnum, str]:
             EnabledDisabledEnum.Enabled: "true",
             EnabledDisabledEnum.Disabled: "false",
         }
+
+
+class TransactionAccessModeEnum(enum.StrEnum):
+    ReadOnly = "ReadOnly"
+    ReadWrite = "ReadWrite"
+
+
+class TransactionAccessMode(
+    EnumScalarType[TransactionAccessModeEnum],
+    edgeql_type="sys::TransactionAccessMode",
+):
+    @classmethod
+    def get_translation_map(cls) -> Mapping[TransactionAccessModeEnum, str]:
+        return {
+            TransactionAccessModeEnum.ReadOnly: "true",
+            TransactionAccessModeEnum.ReadWrite: "false",
+        }
+
+
+class TransactionDeferrabilityEnum(enum.StrEnum):
+    Deferrable = "Deferrable"
+    NotDeferrable = "NotDeferrable"
+
+
+class TransactionDeferrability(
+    EnumScalarType[TransactionDeferrabilityEnum],
+    edgeql_type="sys::TransactionDeferrability",
+):
+    @classmethod
+    def get_translation_map(cls) -> Mapping[TransactionDeferrabilityEnum, str]:
+        return {
+            TransactionDeferrabilityEnum.Deferrable: "true",
+            TransactionDeferrabilityEnum.NotDeferrable: "false",
+        }
+
+
+class TransactionIsolationEnum(enum.StrEnum):
+    Serializable = "Serializable"
+    RepeatableRead = "RepeatableRead"
+
+
+class TransactionIsolation(
+    EnumScalarType[TransactionIsolationEnum],
+    edgeql_type="sys::TransactionIsolation",
+):
+    @classmethod
+    def get_translation_map(cls) -> Mapping[TransactionIsolationEnum, str]:
+        return {
+            TransactionIsolationEnum.Serializable: "serializable",
+            TransactionIsolationEnum.RepeatableRead: "repeatable read",
+        }
diff --git a/edb/lib/cfg.edgeql b/edb/lib/cfg.edgeql
index 9b2d672c626f..d42309561d74 100644
--- a/edb/lib/cfg.edgeql
+++ b/edb/lib/cfg.edgeql
@@ -188,6 +188,47 @@ ALTER TYPE cfg::AbstractConfig {
         SET default := <std::duration>'60 seconds';
     };
 
+    CREATE REQUIRED PROPERTY default_transaction_isolation
+        -> sys::TransactionIsolation
+    {
+        CREATE ANNOTATION cfg::backend_setting :=
+            '"default_transaction_isolation"';
+        CREATE ANNOTATION std::description :=
+            'Controls the default isolation level of each new transaction, \
+            including implicit transactions. Defaults to `Serializable`. \
+            Note that changing this to a lower isolation level implies \
+            that the transactions are also read-only by default regardless \
+            of the value of the `default_transaction_access_mode` setting.';
+        SET default := sys::TransactionIsolation.Serializable;
+    };
+
+    CREATE REQUIRED PROPERTY default_transaction_access_mode
+        -> sys::TransactionAccessMode
+    {
+        CREATE ANNOTATION cfg::backend_setting :=
+            '"default_transaction_read_only"';
+        CREATE ANNOTATION std::description :=
+            'Controls the default read-only status of each new transaction, \
+            including implicit transactions. Defaults to `ReadWrite`. \
+            Note that if `default_transaction_isolation` is set to any value \
+            other than Serializable this parameter is implied to be \
+            `ReadOnly` regardless of the actual value.';
+        SET default := sys::TransactionAccessMode.ReadWrite;
+    };
+
+    CREATE REQUIRED PROPERTY default_transaction_deferrable
+        -> sys::TransactionDeferrability
+    {
+        CREATE ANNOTATION cfg::backend_setting :=
+            '"default_transaction_deferrable"';
+        CREATE ANNOTATION std::description :=
+            'Controls the default deferrable status of each new transaction. \
+            It currently has no effect on read-write transactions or those \
+            operating at isolation levels lower than `Serializable`. \
+            The default is `NotDeferrable`.';
+        SET default := sys::TransactionDeferrability.NotDeferrable;
+    };
+
     CREATE REQUIRED PROPERTY session_idle_transaction_timeout -> std::duration {
         CREATE ANNOTATION cfg::backend_setting :=
             '"idle_in_transaction_session_timeout"';
diff --git a/edb/lib/sys.edgeql b/edb/lib/sys.edgeql
index 67ebe6c846fc..57385e822c6a 100644
--- a/edb/lib/sys.edgeql
+++ b/edb/lib/sys.edgeql
@@ -24,6 +24,14 @@ CREATE SCALAR TYPE sys::TransactionIsolation
     EXTENDING enum<RepeatableRead, Serializable>;
 
 
+CREATE SCALAR TYPE sys::TransactionAccessMode
+    EXTENDING enum<ReadOnly, ReadWrite>;
+
+
+CREATE SCALAR TYPE sys::TransactionDeferrability
+    EXTENDING enum<Deferrable, NotDeferrable>;
+
+
 CREATE SCALAR TYPE sys::VersionStage
     EXTENDING enum<dev, alpha, beta, rc, final>;