refactor useless interfaces

Author: vgvoleg

ydb/aio/query/pool.py

@@ -14,14 +14,15 @@
     retry_operation_async,
 )
 from ... import convert
+from ..._grpc.grpcwrapper import common_utils
 
 logger = logging.getLogger(__name__)
 
 
 class QuerySessionPoolAsync:
     """QuerySessionPoolAsync is an object to simplify operations with sessions of Query Service."""
 
-    def __init__(self, driver: base.SupportedDriverType):
+    def __init__(self, driver: common_utils.SupportedDriverType):
         """
         :param driver: A driver instance
         """
@@ -85,7 +86,7 @@ def __init__(self, pool: QuerySessionPoolAsync):
         self._pool = pool
         self._session = QuerySessionAsync(pool._driver)
 
-    async def __aenter__(self) -> base.IQuerySession:
+    async def __aenter__(self) -> QuerySessionAsync:
         await self._session.create()
         return self._session
 

ydb/aio/query/session.py

@@ -28,7 +28,7 @@ class QuerySessionAsync(BaseQuerySession):
 
     def __init__(
         self,
-        driver: base.SupportedDriverType,
+        driver: common_utils.SupportedDriverType,
         settings: Optional[base.QueryClientSettings] = None,
         loop: asyncio.AbstractEventLoop = None,
     ):
@@ -90,7 +90,7 @@ async def create(self) -> "QuerySessionAsync":
 
         return self
 
-    def transaction(self, tx_mode=None) -> base.IQueryTxContext:
+    def transaction(self, tx_mode=None) -> QueryTxContextAsync:
         self._state._check_session_ready_to_use()
         tx_mode = tx_mode if tx_mode else _ydb_query_public.QuerySerializableReadWrite()
 

ydb/aio/query/transaction.py

@@ -46,7 +46,7 @@ async def _ensure_prev_stream_finished(self) -> None:
                 pass
             self._prev_stream = None
 
-    async def begin(self, settings: Optional[base.QueryClientSettings] = None) -> None:
+    async def begin(self, settings: Optional[base.QueryClientSettings] = None) -> "QueryTxContextAsync":
         """WARNING: This API is experimental and could be changed.
 
         Explicitly begins a transaction
@@ -79,6 +79,15 @@ async def commit(self, settings: Optional[base.QueryClientSettings] = None) -> N
         await self._commit_call(settings)
 
     async def rollback(self, settings: Optional[base.QueryClientSettings] = None) -> None:
+        """WARNING: This API is experimental and could be changed.
+
+        Calls rollback on a transaction if it is open otherwise is no-op. If transaction execution
+        failed then this method raises PreconditionFailed.
+
+        :param settings: A request settings
+
+        :return: A committed transaction or exception if commit is failed
+        """
         if self._tx_state._already_in(QueryTxStateEnum.ROLLBACKED):
             return
 
@@ -93,16 +102,18 @@ async def rollback(self, settings: Optional[base.QueryClientSettings] = None) ->
     async def execute(
         self,
         query: str,
+        parameters: Optional[dict] = None,
         commit_tx: Optional[bool] = False,
         syntax: Optional[base.QuerySyntax] = None,
         exec_mode: Optional[base.QueryExecMode] = None,
-        parameters: Optional[dict] = None,
         concurrent_result_sets: Optional[bool] = False,
+        settings: Optional[base.QueryClientSettings] = None,
     ) -> AsyncResponseContextIterator:
         """WARNING: This API is experimental and could be changed.
 
         Sends a query to Query Service
         :param query: (YQL or SQL text) to be executed.
+        :param parameters: dict with parameters and YDB types;
         :param commit_tx: A special flag that allows transaction commit.
         :param syntax: Syntax of the query, which is a one from the following choises:
          1) QuerySyntax.YQL_V1, which is default;
@@ -112,7 +123,6 @@ async def execute(
          2) QueryExecMode.EXPLAIN;
          3) QueryExecMode.VALIDATE;
          4) QueryExecMode.PARSE.
-        :param parameters: dict with parameters and YDB types;
         :param concurrent_result_sets: A flag to allow YDB mix parts of different result sets. Default is False;
 
         :return: Iterator with result sets
@@ -128,6 +138,7 @@ async def execute(
             concurrent_result_sets=concurrent_result_sets,
         )
 
+        settings = settings if settings is not None else self.session._settings
         self._prev_stream = AsyncResponseContextIterator(
             stream_it,
             lambda resp: base.wrap_execute_query_response(

ydb/query/__init__.py

@@ -11,13 +11,12 @@
 import logging
 
 from .base import (
-    IQueryClient,
-    SupportedDriverType,
     QueryClientSettings,
 )
 
 from .session import QuerySessionSync
 
+from .._grpc.grpcwrapper import common_utils
 from .._grpc.grpcwrapper.ydb_query_public_types import (
     QueryOnlineReadOnly,
     QuerySerializableReadWrite,
@@ -30,8 +29,8 @@
 logger = logging.getLogger(__name__)
 
 
-class QueryClientSync(IQueryClient):
-    def __init__(self, driver: SupportedDriverType, query_client_settings: QueryClientSettings = None):
+class QueryClientSync:
+    def __init__(self, driver: common_utils.SupportedDriverType, query_client_settings: QueryClientSettings = None):
         logger.warning("QueryClientSync is an experimental API, which could be changed.")
         self._driver = driver
         self._settings = query_client_settings

ydb/query/base.py

@@ -2,14 +2,11 @@
 import enum
 import functools
 
+import typing
 from typing import (
-    Iterator,
     Optional,
 )
 
-from .._grpc.grpcwrapper.common_utils import (
-    SupportedDriverType,
-)
 from .._grpc.grpcwrapper import ydb_query
 from .._grpc.grpcwrapper.ydb_query_public_types import (
     BaseQueryTxMode,
@@ -20,6 +17,9 @@
 from .. import _utilities
 from .. import _apis
 
+if typing.TYPE_CHECKING:
+    from .transaction import BaseQueryTxContext
+
 
 class QuerySyntax(enum.IntEnum):
     UNSPECIFIED = 0
@@ -117,231 +117,6 @@ def set_attached(self, attached: bool) -> "IQuerySessionState":
         pass
 
 
-class IQuerySession(abc.ABC):
-    """Session object for Query Service. It is not recommended to control
-    session's lifecycle manually - use a QuerySessionPool is always a better choise.
-    """
-
-    @abc.abstractmethod
-    def __init__(self, driver: SupportedDriverType, settings: Optional[QueryClientSettings] = None):
-        pass
-
-    @abc.abstractmethod
-    def create(self) -> "IQuerySession":
-        """WARNING: This API is experimental and could be changed.
-
-        Creates a Session of Query Service on server side and attaches it.
-
-        :return: Session object.
-        """
-        pass
-
-    @abc.abstractmethod
-    def delete(self) -> None:
-        """WARNING: This API is experimental and could be changed.
-
-        Deletes a Session of Query Service on server side and releases resources.
-
-        :return: None
-        """
-        pass
-
-    @abc.abstractmethod
-    def transaction(self, tx_mode: Optional[BaseQueryTxMode] = None) -> "IQueryTxContext":
-        """WARNING: This API is experimental and could be changed.
-
-        Creates a transaction context manager with specified transaction mode.
-
-        :param tx_mode: Transaction mode, which is a one from the following choises:
-         1) QuerySerializableReadWrite() which is default mode;
-         2) QueryOnlineReadOnly(allow_inconsistent_reads=False);
-         3) QuerySnapshotReadOnly();
-         4) QueryStaleReadOnly().
-
-        :return: transaction context manager.
-        """
-        pass
-
-    @abc.abstractmethod
-    def execute(
-        self,
-        query: str,
-        parameters: Optional[dict] = None,
-        syntax: Optional[QuerySyntax] = None,
-        exec_mode: Optional[QueryExecMode] = None,
-        concurrent_result_sets: Optional[bool] = False,
-    ) -> Iterator:
-        """WARNING: This API is experimental and could be changed.
-
-        Sends a query to Query Service
-        :param query: (YQL or SQL text) to be executed.
-        :param syntax: Syntax of the query, which is a one from the following choises:
-         1) QuerySyntax.YQL_V1, which is default;
-         2) QuerySyntax.PG.
-        :param parameters: dict with parameters and YDB types;
-        :param concurrent_result_sets: A flag to allow YDB mix parts of different result sets. Default is False;
-
-        :return: Iterator with result sets
-        """
-
-
-class IQueryTxContext(abc.ABC):
-    """
-    An object that provides a simple transaction context manager that allows statements execution
-    in a transaction. You don't have to open transaction explicitly, because context manager encapsulates
-    transaction control logic, and opens new transaction if:
-     1) By explicit .begin();
-     2) On execution of a first statement, which is strictly recommended method, because that avoids
-     useless round trip
-
-    This context manager is not thread-safe, so you should not manipulate on it concurrently.
-    """
-
-    @abc.abstractmethod
-    def __init__(
-        self,
-        driver: SupportedDriverType,
-        session_state: IQuerySessionState,
-        session: IQuerySession,
-        tx_mode: BaseQueryTxMode,
-    ):
-        """
-        An object that provides a simple transaction context manager that allows statements execution
-        in a transaction. You don't have to open transaction explicitly, because context manager encapsulates
-        transaction control logic, and opens new transaction if:
-
-        1) By explicit .begin() method;
-        2) On execution of a first statement, which is strictly recommended method, because that avoids useless round trip
-
-        This context manager is not thread-safe, so you should not manipulate on it concurrently.
-
-        :param driver: A driver instance
-        :param session_state: A state of session
-        :param tx_mode: Transaction mode, which is a one from the following choises:
-         1) QuerySerializableReadWrite() which is default mode;
-         2) QueryOnlineReadOnly(allow_inconsistent_reads=False);
-         3) QuerySnapshotReadOnly();
-         4) QueryStaleReadOnly().
-        """
-        pass
-
-    @abc.abstractmethod
-    def __enter__(self) -> "IQueryTxContext":
-        """
-        Enters a context manager and returns a transaction
-
-        :return: A transaction instance
-        """
-        pass
-
-    @abc.abstractmethod
-    def __exit__(self, *args, **kwargs):
-        """
-        Closes a transaction context manager and rollbacks transaction if
-        it is not finished explicitly
-        """
-        pass
-
-    @property
-    @abc.abstractmethod
-    def session_id(self) -> str:
-        """
-        A transaction's session id
-
-        :return: A transaction's session id
-        """
-        pass
-
-    @property
-    @abc.abstractmethod
-    def tx_id(self) -> Optional[str]:
-        """
-        Returns an id of open transaction or None otherwise
-
-        :return: An id of open transaction or None otherwise
-        """
-        pass
-
-    @abc.abstractmethod
-    def begin(self, settings: Optional[QueryClientSettings] = None) -> "IQueryTxContext":
-        """WARNING: This API is experimental and could be changed.
-
-        Explicitly begins a transaction
-
-        :param settings: A request settings
-
-        :return: Transaction object or exception if begin is failed
-        """
-        pass
-
-    @abc.abstractmethod
-    def commit(self, settings: Optional[QueryClientSettings] = None) -> None:
-        """WARNING: This API is experimental and could be changed.
-
-        Calls commit on a transaction if it is open. If transaction execution
-        failed then this method raises PreconditionFailed.
-
-        :param settings: A request settings
-
-        :return: None or exception if commit is failed
-        """
-        pass
-
-    @abc.abstractmethod
-    def rollback(self, settings: Optional[QueryClientSettings] = None) -> None:
-        """WARNING: This API is experimental and could be changed.
-
-        Calls rollback on a transaction if it is open. If transaction execution
-        failed then this method raises PreconditionFailed.
-
-        :param settings: A request settings
-
-        :return: None or exception if rollback is failed
-        """
-        pass
-
-    @abc.abstractmethod
-    def execute(
-        self,
-        query: str,
-        commit_tx: Optional[bool] = False,
-        syntax: Optional[QuerySyntax] = None,
-        exec_mode: Optional[QueryExecMode] = None,
-        parameters: Optional[dict] = None,
-        concurrent_result_sets: Optional[bool] = False,
-        settings: Optional[QueryClientSettings] = None,
-    ) -> Iterator:
-        """WARNING: This API is experimental and could be changed.
-
-        Sends a query to Query Service
-        :param query: (YQL or SQL text) to be executed.
-        :param commit_tx: A special flag that allows transaction commit.
-        :param syntax: Syntax of the query, which is a one from the following choises:
-         1) QuerySyntax.YQL_V1, which is default;
-         2) QuerySyntax.PG.
-        :param exec_mode: Exec mode of the query, which is a one from the following choises:
-         1) QueryExecMode.EXECUTE, which is default;
-         2) QueryExecMode.EXPLAIN;
-         3) QueryExecMode.VALIDATE;
-         4) QueryExecMode.PARSE.
-        :param parameters: dict with parameters and YDB types;
-        :param concurrent_result_sets: A flag to allow YDB mix parts of different result sets. Default is False;
-        :param settings: An additional request settings QueryClientSettings;
-
-        :return: Iterator with result sets
-        """
-        pass
-
-
-class IQueryClient(abc.ABC):
-    def __init__(self, driver: SupportedDriverType, query_client_settings: Optional[QueryClientSettings] = None):
-        pass
-
-    @abc.abstractmethod
-    def session(self) -> IQuerySession:
-        pass
-
-
 def create_execute_query_request(
     query: str,
     session_id: str,
@@ -392,7 +167,7 @@ def create_execute_query_request(
 def wrap_execute_query_response(
     rpc_state: RpcState,
     response_pb: _apis.ydb_query.ExecuteQueryResponsePart,
-    tx: Optional[IQueryTxContext] = None,
+    tx: Optional["BaseQueryTxContext"] = None,
     commit_tx: Optional[bool] = False,
     settings: Optional[QueryClientSettings] = None,
 ) -> convert.ResultSet: