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

@@ -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
 
 

edb/ir/statypes.py

@@ -736,3 +736,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",
+        }

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"';

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>;