This partially reverts commit 300b877.

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 = 2025_02_04_00_00
+EDGEDB_CATALOG_VERSION = 2025_02_12_00_00
 EDGEDB_MAJOR_VERSION = 7
 
 

edb/ir/statypes.py

@@ -27,7 +27,6 @@
     Optional,
     Self,
     TypeVar,
-    TYPE_CHECKING,
 )
 
 import dataclasses
@@ -48,9 +47,6 @@
 from edb.schema import name as s_name
 from edb.schema import objects as s_obj
 
-if TYPE_CHECKING:
-    from edb.edgeql import qltypes
-
 MISSING: Any = object()
 
 
@@ -740,74 +736,3 @@ 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",
-        }
-
-    def to_qltypes(self) -> qltypes.TransactionAccessMode:
-        from edb.edgeql import qltypes
-        match self._val:
-            case TransactionAccessModeEnum.ReadOnly:
-                return qltypes.TransactionAccessMode.READ_ONLY
-            case TransactionAccessModeEnum.ReadWrite:
-                return qltypes.TransactionAccessMode.READ_WRITE
-            case _:
-                raise AssertionError(f"unexpected value: {self._val!r}")
-
-
-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",
-        }
-
-    def to_qltypes(self) -> qltypes.TransactionIsolationLevel:
-        from edb.edgeql import qltypes
-        match self._val:
-            case TransactionIsolationEnum.Serializable:
-                return qltypes.TransactionIsolationLevel.SERIALIZABLE
-            case TransactionIsolationEnum.RepeatableRead:
-                return qltypes.TransactionIsolationLevel.REPEATABLE_READ
-            case _:
-                raise AssertionError(f"unexpected value: {self._val!r}")

edb/lib/cfg.edgeql

@@ -188,47 +188,6 @@ ALTER TYPE cfg::AbstractConfig {
         SET default := <std::duration>'60 seconds';
     };
 
-    CREATE REQUIRED PROPERTY default_transaction_isolation
-        -> sys::TransactionIsolation
-    {
-        CREATE ANNOTATION cfg::affects_compilation := 'true';
-        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::affects_compilation := 'true';
-        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,14 +24,6 @@ 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>;
 

edb/server/compiler/compiler.py

@@ -66,7 +66,6 @@
 from edb.edgeql import qltypes
 
 from edb.ir import staeval as ireval
-from edb.ir import statypes
 from edb.ir import ast as irast
 
 from edb.schema import ddl as s_ddl
@@ -2153,39 +2152,22 @@ def _compile_ql_transaction(
 
         ctx.state.start_tx()
 
-        # Compute the effective isolation level
-        iso_config: statypes.TransactionIsolation = _get_config_val(
-            ctx, "default_transaction_isolation"
-        )
-        default_iso = iso_config.to_qltypes()
+        sqls = 'START TRANSACTION'
         iso = ql.isolation
-        if iso is None:
-            iso = default_iso
-
-        # Compute the effective access mode
-        access = ql.access
-        if access is None:
-            if default_iso is qltypes.TransactionIsolationLevel.SERIALIZABLE:
-                access_mode: statypes.TransactionAccessMode = _get_config_val(
-                    ctx, "default_transaction_access_mode"
+        if iso is not None:
+            if (
+                iso is not qltypes.TransactionIsolationLevel.SERIALIZABLE
+                and ql.access is not qltypes.TransactionAccessMode.READ_ONLY
+            ):
+                raise errors.TransactionError(
+                    f"{iso.value} transaction isolation level is only "
+                    "supported in read-only transactions",
+                    span=ql.span,
+                    hint=f"specify READ ONLY access mode",
                 )
-                access = access_mode.to_qltypes()
-            else:
-                access = qltypes.TransactionAccessMode.READ_ONLY
-
-        # Guard against unsupported isolation + access combinations
-        if (
-            iso is not qltypes.TransactionIsolationLevel.SERIALIZABLE
-            and access is not qltypes.TransactionAccessMode.READ_ONLY
-        ):
-            raise errors.TransactionError(
-                f"{iso.value} transaction isolation level is only "
-                "supported in read-only transactions",
-                span=ql.span,
-                hint=f"specify READ ONLY access mode",
-            )
-
-        sqls = f'START TRANSACTION ISOLATION LEVEL {iso.value} {access.value}'
+            sqls += f' ISOLATION LEVEL {iso.value}'
+        if ql.access is not None:
+            sqls += f' {ql.access.value}'
         if ql.deferrable is not None:
             sqls += f' {ql.deferrable.value}'
         sqls += ';'

edb/server/compiler/explain/to_json.py

@@ -21,8 +21,6 @@
 import enum
 import uuid
 
-from edb.ir import statypes
-
 
 class ToJson:
     def to_json(self) -> Any:
@@ -38,6 +36,4 @@ def json_hook(value: Any) -> Any:
         return value.value
     elif isinstance(value, (frozenset, set)):
         return list(value)
-    elif isinstance(value, statypes.ScalarType):
-        return value.to_json()
     raise TypeError(f"Cannot serialize {value!r}")

edb/server/dbview/dbview.pyx

@@ -1709,23 +1709,6 @@ cdef class DatabaseConnectionView:
                     msg,
                 )
 
-        if not self.in_tx() and query_capabilities & enums.Capability.WRITE:
-            isolation = self.config_lookup("default_transaction_isolation")
-            if isolation and isolation.to_str() != "Serializable":
-                raise query_capabilities.make_error(
-                    ~enums.Capability.WRITE,
-                    errors.TransactionError,
-                    f"default_transaction_isolation is set to "
-                    f"{isolation.to_str()}",
-                )
-            access_mode = self.config_lookup("default_transaction_access_mode")
-            if access_mode and access_mode.to_str() == "ReadOnly":
-                raise query_capabilities.make_error(
-                    ~enums.Capability.WRITE,
-                    errors.TransactionError,
-                    "default_transaction_access_mode is set to ReadOnly",
-                )
-
     async def reload_state_serializer(self):
         # This should only happen once when a different protocol version is
         # used after schema change, or non-current version of protocol is used