From 051bfbbaf771529e33ba46c21e1b3486ab43008f Mon Sep 17 00:00:00 2001
From: Oleg Ovcharuk <vgvoleg@gmail.com>
Date: Wed, 21 Aug 2024 12:22:10 +0300
Subject: [PATCH 1/3] Add huge select example to basic example v2

---
 examples/basic_example_v2/basic_example.py    | 20 +++++++++++++++++++
 .../basic_example_v2/basic_example_async.py   | 20 +++++++++++++++++++
 2 files changed, 40 insertions(+)

diff --git a/examples/basic_example_v2/basic_example.py b/examples/basic_example_v2/basic_example.py
index 52d580bd..d6da8087 100644
--- a/examples/basic_example_v2/basic_example.py
+++ b/examples/basic_example_v2/basic_example.py
@@ -183,6 +183,25 @@ def callee(session: ydb.QuerySessionSync):
     return pool.retry_operation_sync(callee)
 
 
+def huge_select(pool: ydb.QuerySessionPool, path: str):
+    def callee(session: ydb.QuerySessionSync):
+        query = f"""
+        PRAGMA TablePathPrefix("{path}");
+        SELECT * from episodes;
+        """
+
+        with session.transaction().execute(
+            query,
+            commit_tx=True,
+        ) as result_sets:
+            print("\n> Huge SELECT call")
+            for result_set in result_sets:
+                for row in result_set.rows:
+                    print("episode title:", row.title, ", air date:", row.air_date)
+
+    return pool.retry_operation_sync(callee)
+
+
 def drop_tables(pool: ydb.QuerySessionPool, path: str):
     print("\nCleaning up existing tables...")
     pool.execute_with_retries(DropTablesQuery.format(path))
@@ -287,3 +306,4 @@ def run(endpoint, database, path):
 
             explicit_transaction_control(pool, full_path, 2, 6, 1)
             select_with_parameters(pool, full_path, 2, 6, 1)
+            huge_select(pool, full_path)
diff --git a/examples/basic_example_v2/basic_example_async.py b/examples/basic_example_v2/basic_example_async.py
index 2bb5cab6..be977471 100644
--- a/examples/basic_example_v2/basic_example_async.py
+++ b/examples/basic_example_v2/basic_example_async.py
@@ -185,6 +185,25 @@ async def callee(session: ydb.aio.QuerySessionAsync):
     return await pool.retry_operation_async(callee)
 
 
+async def huge_select(pool: ydb.aio.QuerySessionPoolAsync, path: str):
+    async def callee(session: ydb.aio.QuerySessionAsync):
+        query = f"""
+        PRAGMA TablePathPrefix("{path}");
+        SELECT * from episodes;
+        """
+
+        async with await session.transaction().execute(
+            query,
+            commit_tx=True,
+        ) as result_sets:
+            print("\n> Huge SELECT call")
+            async for result_set in result_sets:
+                for row in result_set.rows:
+                    print("episode title:", row.title, ", air date:", row.air_date)
+
+    return await pool.retry_operation_async(callee)
+
+
 async def drop_tables(pool: ydb.aio.QuerySessionPoolAsync, path: str):
     print("\nCleaning up existing tables...")
     await pool.execute_with_retries(DropTablesQuery.format(path))
@@ -289,3 +308,4 @@ async def run(endpoint, database, path):
 
             await explicit_transaction_control(pool, full_path, 2, 6, 1)
             await select_with_parameters(pool, full_path, 2, 6, 1)
+            await huge_select(pool, full_path)

From f07ad801d2b844e05546a25332f3c89d0c8e7eb7 Mon Sep 17 00:00:00 2001
From: Oleg Ovcharuk <vgvoleg@gmail.com>
Date: Wed, 21 Aug 2024 12:44:30 +0300
Subject: [PATCH 2/3] Remove PragmaTablePrefix and add Declare to example

---
 examples/basic_example_v2/__main__.py         |   5 +-
 examples/basic_example_v2/basic_example.py    | 124 ++++++-----------
 .../basic_example_v2/basic_example_async.py   | 125 ++++++------------
 3 files changed, 81 insertions(+), 173 deletions(-)

diff --git a/examples/basic_example_v2/__main__.py b/examples/basic_example_v2/__main__.py
index 9c68c00d..95ecf99e 100644
--- a/examples/basic_example_v2/__main__.py
+++ b/examples/basic_example_v2/__main__.py
@@ -11,9 +11,8 @@
         formatter_class=argparse.RawDescriptionHelpFormatter,
         description="""\033[92mYDB basic example.\x1b[0m\n""",
     )
-    parser.add_argument("-d", "--database", help="Name of the database to use", default="/local")
     parser.add_argument("-e", "--endpoint", help="Endpoint url to use", default="grpc://localhost:2136")
-    parser.add_argument("-p", "--path", default="")
+    parser.add_argument("-d", "--database", help="Name of the database to use", default="/local")
     parser.add_argument("-v", "--verbose", default=False, action="store_true")
     parser.add_argument("-m", "--mode", default="sync", help="Mode of example: sync or async")
 
@@ -28,7 +27,6 @@
         run_sync(
             args.endpoint,
             args.database,
-            args.path,
         )
     elif args.mode == "async":
         print("Running async example")
@@ -36,7 +34,6 @@
             run_async(
                 args.endpoint,
                 args.database,
-                args.path,
             )
         )
     else:
diff --git a/examples/basic_example_v2/basic_example.py b/examples/basic_example_v2/basic_example.py
index d6da8087..ed05554b 100644
--- a/examples/basic_example_v2/basic_example.py
+++ b/examples/basic_example_v2/basic_example.py
@@ -1,26 +1,15 @@
 # -*- coding: utf-8 -*-
-import posixpath
 import ydb
 import basic_example_data
 
-# Table path prefix allows to put the working tables into the specific directory
-# inside the YDB database. Putting `PRAGMA TablePathPrefix("some/path")`
-# at the beginning of the query allows to reference the tables through
-# their names "under" the specified directory.
-#
-# TablePathPrefix has to be defined as an absolute path, which has to be started
-# with the current database location.
-#
-# https://ydb.tech/ru/docs/yql/reference/syntax/pragma#table-path-prefix
-
-DropTablesQuery = """PRAGMA TablePathPrefix("{}");
+
+DropTablesQuery = """
 DROP TABLE IF EXISTS series;
 DROP TABLE IF EXISTS seasons;
 DROP TABLE IF EXISTS episodes;
 """
 
-FillDataQuery = """PRAGMA TablePathPrefix("{}");
-
+FillDataQuery = """
 DECLARE $seriesData AS List<Struct<
     series_id: Int64,
     title: Utf8,
@@ -69,13 +58,11 @@
 """
 
 
-def fill_tables_with_data(pool: ydb.QuerySessionPool, path: str):
+def fill_tables_with_data(pool: ydb.QuerySessionPool):
     print("\nFilling tables with data...")
 
-    query = FillDataQuery.format(path)
-
     pool.execute_with_retries(
-        query,
+        FillDataQuery,
         {
             "$seriesData": (basic_example_data.get_series_data(), basic_example_data.get_series_data_type()),
             "$seasonsData": (basic_example_data.get_seasons_data(), basic_example_data.get_seasons_data_type()),
@@ -84,11 +71,10 @@ def fill_tables_with_data(pool: ydb.QuerySessionPool, path: str):
     )
 
 
-def select_simple(pool: ydb.QuerySessionPool, path: str):
+def select_simple(pool: ydb.QuerySessionPool):
     print("\nCheck series table...")
     result_sets = pool.execute_with_retries(
-        f"""
-        PRAGMA TablePathPrefix("{path}");
+        """
         SELECT
             series_id,
             title,
@@ -111,21 +97,23 @@ def select_simple(pool: ydb.QuerySessionPool, path: str):
     return first_set
 
 
-def upsert_simple(pool: ydb.QuerySessionPool, path: str):
+def upsert_simple(pool: ydb.QuerySessionPool):
     print("\nPerforming UPSERT into episodes...")
 
     pool.execute_with_retries(
-        f"""
-        PRAGMA TablePathPrefix("{path}");
+        """
         UPSERT INTO episodes (series_id, season_id, episode_id, title) VALUES (2, 6, 1, "TBD");
         """
     )
 
 
-def select_with_parameters(pool: ydb.QuerySessionPool, path: str, series_id, season_id, episode_id):
+def select_with_parameters(pool: ydb.QuerySessionPool, series_id, season_id, episode_id):
     result_sets = pool.execute_with_retries(
-        f"""
-        PRAGMA TablePathPrefix("{path}");
+        """
+        DECLARE $seriesId AS Int64;
+        DECLARE $seasonId AS Int64;
+        DECLARE $episodeId AS Int64;
+
         SELECT
             title,
             air_date
@@ -151,10 +139,13 @@ def select_with_parameters(pool: ydb.QuerySessionPool, path: str, series_id, sea
 # In most cases it's better to use transaction control settings in session.transaction
 # calls instead to avoid additional hops to YDB cluster and allow more efficient
 # execution of queries.
-def explicit_transaction_control(pool: ydb.QuerySessionPool, path: str, series_id, season_id, episode_id):
+def explicit_transaction_control(pool: ydb.QuerySessionPool, series_id, season_id, episode_id):
     def callee(session: ydb.QuerySessionSync):
-        query = f"""
-        PRAGMA TablePathPrefix("{path}");
+        query = """
+        DECLARE $seriesId AS Int64;
+        DECLARE $seasonId AS Int64;
+        DECLARE $episodeId AS Int64;
+
         UPDATE episodes
         SET air_date = CurrentUtcDate()
         WHERE series_id = $seriesId AND season_id = $seasonId AND episode_id = $episodeId;
@@ -183,12 +174,9 @@ def callee(session: ydb.QuerySessionSync):
     return pool.retry_operation_sync(callee)
 
 
-def huge_select(pool: ydb.QuerySessionPool, path: str):
+def huge_select(pool: ydb.QuerySessionPool):
     def callee(session: ydb.QuerySessionSync):
-        query = f"""
-        PRAGMA TablePathPrefix("{path}");
-        SELECT * from episodes;
-        """
+        query = """SELECT * from episodes;"""
 
         with session.transaction().execute(
             query,
@@ -202,16 +190,15 @@ def callee(session: ydb.QuerySessionSync):
     return pool.retry_operation_sync(callee)
 
 
-def drop_tables(pool: ydb.QuerySessionPool, path: str):
+def drop_tables(pool: ydb.QuerySessionPool):
     print("\nCleaning up existing tables...")
-    pool.execute_with_retries(DropTablesQuery.format(path))
+    pool.execute_with_retries(DropTablesQuery)
 
 
-def create_tables(pool: ydb.QuerySessionPool, path: str):
+def create_tables(pool: ydb.QuerySessionPool):
     print("\nCreating table series...")
     pool.execute_with_retries(
-        f"""
-        PRAGMA TablePathPrefix("{path}");
+        """
         CREATE table `series` (
             `series_id` Int64,
             `title` Utf8,
@@ -224,8 +211,7 @@ def create_tables(pool: ydb.QuerySessionPool, path: str):
 
     print("\nCreating table seasons...")
     pool.execute_with_retries(
-        f"""
-        PRAGMA TablePathPrefix("{path}");
+        """
         CREATE table `seasons` (
             `series_id` Int64,
             `season_id` Int64,
@@ -239,8 +225,7 @@ def create_tables(pool: ydb.QuerySessionPool, path: str):
 
     print("\nCreating table episodes...")
     pool.execute_with_retries(
-        f"""
-        PRAGMA TablePathPrefix("{path}");
+        """
         CREATE table `episodes` (
             `series_id` Int64,
             `season_id` Int64,
@@ -253,29 +238,7 @@ def create_tables(pool: ydb.QuerySessionPool, path: str):
     )
 
 
-def is_directory_exists(driver: ydb.Driver, path: str):
-    try:
-        return driver.scheme_client.describe_path(path).is_directory()
-    except ydb.SchemeError:
-        return False
-
-
-def ensure_path_exists(driver, database, path):
-    paths_to_create = list()
-    path = path.rstrip("/")
-    while path not in ("", database):
-        full_path = posixpath.join(database, path)
-        if is_directory_exists(driver, full_path):
-            break
-        paths_to_create.append(full_path)
-        path = posixpath.dirname(path).rstrip("/")
-
-    while len(paths_to_create) > 0:
-        full_path = paths_to_create.pop(-1)
-        driver.scheme_client.make_directory(full_path)
-
-
-def run(endpoint, database, path):
+def run(endpoint, database):
     with ydb.Driver(
         endpoint=endpoint,
         database=database,
@@ -284,26 +247,19 @@ def run(endpoint, database, path):
         driver.wait(timeout=5, fail_fast=True)
 
         with ydb.QuerySessionPool(driver) as pool:
+            drop_tables(pool)
 
-            ensure_path_exists(driver, database, path)
-
-            # absolute path - prefix to the table's names,
-            # including the database location
-            full_path = posixpath.join(database, path)
-
-            drop_tables(pool, full_path)
-
-            create_tables(pool, full_path)
+            create_tables(pool)
 
-            fill_tables_with_data(pool, full_path)
+            fill_tables_with_data(pool)
 
-            select_simple(pool, full_path)
+            select_simple(pool)
 
-            upsert_simple(pool, full_path)
+            upsert_simple(pool)
 
-            select_with_parameters(pool, full_path, 2, 3, 7)
-            select_with_parameters(pool, full_path, 2, 3, 8)
+            select_with_parameters(pool, 2, 3, 7)
+            select_with_parameters(pool, 2, 3, 8)
 
-            explicit_transaction_control(pool, full_path, 2, 6, 1)
-            select_with_parameters(pool, full_path, 2, 6, 1)
-            huge_select(pool, full_path)
+            explicit_transaction_control(pool, 2, 6, 1)
+            select_with_parameters(pool, 2, 6, 1)
+            huge_select(pool)
diff --git a/examples/basic_example_v2/basic_example_async.py b/examples/basic_example_v2/basic_example_async.py
index be977471..e35fbabc 100644
--- a/examples/basic_example_v2/basic_example_async.py
+++ b/examples/basic_example_v2/basic_example_async.py
@@ -1,26 +1,15 @@
 # -*- coding: utf-8 -*-
-import posixpath
 import ydb
 import basic_example_data
 
-# Table path prefix allows to put the working tables into the specific directory
-# inside the YDB database. Putting `PRAGMA TablePathPrefix("some/path")`
-# at the beginning of the query allows to reference the tables through
-# their names "under" the specified directory.
-#
-# TablePathPrefix has to be defined as an absolute path, which has to be started
-# with the current database location.
-#
-# https://ydb.tech/ru/docs/yql/reference/syntax/pragma#table-path-prefix
-
-DropTablesQuery = """PRAGMA TablePathPrefix("{}");
+
+DropTablesQuery = """
 DROP TABLE IF EXISTS series;
 DROP TABLE IF EXISTS seasons;
 DROP TABLE IF EXISTS episodes;
 """
 
-FillDataQuery = """PRAGMA TablePathPrefix("{}");
-
+FillDataQuery = """
 DECLARE $seriesData AS List<Struct<
     series_id: Int64,
     title: Utf8,
@@ -69,13 +58,10 @@
 """
 
 
-async def fill_tables_with_data(pool: ydb.aio.QuerySessionPoolAsync, path: str):
+async def fill_tables_with_data(pool: ydb.aio.QuerySessionPoolAsync):
     print("\nFilling tables with data...")
-
-    query = FillDataQuery.format(path)
-
     await pool.execute_with_retries(
-        query,
+        FillDataQuery,
         {
             "$seriesData": (basic_example_data.get_series_data(), basic_example_data.get_series_data_type()),
             "$seasonsData": (basic_example_data.get_seasons_data(), basic_example_data.get_seasons_data_type()),
@@ -84,11 +70,10 @@ async def fill_tables_with_data(pool: ydb.aio.QuerySessionPoolAsync, path: str):
     )
 
 
-async def select_simple(pool: ydb.aio.QuerySessionPoolAsync, path: str):
+async def select_simple(pool: ydb.aio.QuerySessionPoolAsync):
     print("\nCheck series table...")
     result_sets = await pool.execute_with_retries(
-        f"""
-        PRAGMA TablePathPrefix("{path}");
+        """
         SELECT
             series_id,
             title,
@@ -111,21 +96,23 @@ async def select_simple(pool: ydb.aio.QuerySessionPoolAsync, path: str):
     return first_set
 
 
-async def upsert_simple(pool: ydb.aio.QuerySessionPoolAsync, path: str):
+async def upsert_simple(pool: ydb.aio.QuerySessionPoolAsync):
     print("\nPerforming UPSERT into episodes...")
 
     await pool.execute_with_retries(
-        f"""
-        PRAGMA TablePathPrefix("{path}");
+        """
         UPSERT INTO episodes (series_id, season_id, episode_id, title) VALUES (2, 6, 1, "TBD");
         """
     )
 
 
-async def select_with_parameters(pool: ydb.aio.QuerySessionPoolAsync, path: str, series_id, season_id, episode_id):
+async def select_with_parameters(pool: ydb.aio.QuerySessionPoolAsync, series_id, season_id, episode_id):
     result_sets = await pool.execute_with_retries(
-        f"""
-        PRAGMA TablePathPrefix("{path}");
+        """
+        DECLARE $seriesId AS Int64;
+        DECLARE $seasonId AS Int64;
+        DECLARE $episodeId AS Int64;
+
         SELECT
             title,
             air_date
@@ -152,11 +139,14 @@ async def select_with_parameters(pool: ydb.aio.QuerySessionPoolAsync, path: str,
 # calls instead to avoid additional hops to YDB cluster and allow more efficient
 # execution of queries.
 async def explicit_transaction_control(
-    pool: ydb.aio.QuerySessionPoolAsync, path: str, series_id, season_id, episode_id
+    pool: ydb.aio.QuerySessionPoolAsync, series_id, season_id, episode_id
 ):
     async def callee(session: ydb.aio.QuerySessionAsync):
-        query = f"""
-        PRAGMA TablePathPrefix("{path}");
+        query = """
+        DECLARE $seriesId AS Int64;
+        DECLARE $seasonId AS Int64;
+        DECLARE $episodeId AS Int64;
+
         UPDATE episodes
         SET air_date = CurrentUtcDate()
         WHERE series_id = $seriesId AND season_id = $seasonId AND episode_id = $episodeId;
@@ -185,12 +175,9 @@ async def callee(session: ydb.aio.QuerySessionAsync):
     return await pool.retry_operation_async(callee)
 
 
-async def huge_select(pool: ydb.aio.QuerySessionPoolAsync, path: str):
+async def huge_select(pool: ydb.aio.QuerySessionPoolAsync):
     async def callee(session: ydb.aio.QuerySessionAsync):
-        query = f"""
-        PRAGMA TablePathPrefix("{path}");
-        SELECT * from episodes;
-        """
+        query = """SELECT * from episodes;"""
 
         async with await session.transaction().execute(
             query,
@@ -204,16 +191,15 @@ async def callee(session: ydb.aio.QuerySessionAsync):
     return await pool.retry_operation_async(callee)
 
 
-async def drop_tables(pool: ydb.aio.QuerySessionPoolAsync, path: str):
+async def drop_tables(pool: ydb.aio.QuerySessionPoolAsync):
     print("\nCleaning up existing tables...")
-    await pool.execute_with_retries(DropTablesQuery.format(path))
+    await pool.execute_with_retries(DropTablesQuery)
 
 
-async def create_tables(pool: ydb.aio.QuerySessionPoolAsync, path: str):
+async def create_tables(pool: ydb.aio.QuerySessionPoolAsync):
     print("\nCreating table series...")
     await pool.execute_with_retries(
-        f"""
-        PRAGMA TablePathPrefix("{path}");
+        """
         CREATE table `series` (
             `series_id` Int64,
             `title` Utf8,
@@ -226,8 +212,7 @@ async def create_tables(pool: ydb.aio.QuerySessionPoolAsync, path: str):
 
     print("\nCreating table seasons...")
     await pool.execute_with_retries(
-        f"""
-        PRAGMA TablePathPrefix("{path}");
+        """
         CREATE table `seasons` (
             `series_id` Int64,
             `season_id` Int64,
@@ -241,8 +226,7 @@ async def create_tables(pool: ydb.aio.QuerySessionPoolAsync, path: str):
 
     print("\nCreating table episodes...")
     await pool.execute_with_retries(
-        f"""
-        PRAGMA TablePathPrefix("{path}");
+        """
         CREATE table `episodes` (
             `series_id` Int64,
             `season_id` Int64,
@@ -255,29 +239,7 @@ async def create_tables(pool: ydb.aio.QuerySessionPoolAsync, path: str):
     )
 
 
-async def is_directory_exists(driver: ydb.aio.Driver, path: str):
-    try:
-        return await driver.scheme_client.describe_path(path).is_directory()
-    except ydb.SchemeError:
-        return False
-
-
-async def ensure_path_exists(driver: ydb.aio.Driver, database, path):
-    paths_to_create = list()
-    path = path.rstrip("/")
-    while path not in ("", database):
-        full_path = posixpath.join(database, path)
-        if await is_directory_exists(driver, full_path):
-            break
-        paths_to_create.append(full_path)
-        path = posixpath.dirname(path).rstrip("/")
-
-    while len(paths_to_create) > 0:
-        full_path = paths_to_create.pop(-1)
-        await driver.scheme_client.make_directory(full_path)
-
-
-async def run(endpoint, database, path):
+async def run(endpoint, database):
     async with ydb.aio.Driver(
         endpoint=endpoint,
         database=database,
@@ -286,26 +248,19 @@ async def run(endpoint, database, path):
         await driver.wait(timeout=5, fail_fast=True)
 
         async with ydb.aio.QuerySessionPoolAsync(driver) as pool:
+            await drop_tables(pool)
 
-            await ensure_path_exists(driver, database, path)
-
-            # absolute path - prefix to the table's names,
-            # including the database location
-            full_path = posixpath.join(database, path)
-
-            await drop_tables(pool, full_path)
-
-            await create_tables(pool, full_path)
+            await create_tables(pool)
 
-            await fill_tables_with_data(pool, full_path)
+            await fill_tables_with_data(pool)
 
-            await select_simple(pool, full_path)
+            await select_simple(pool)
 
-            await upsert_simple(pool, full_path)
+            await upsert_simple(pool)
 
-            await select_with_parameters(pool, full_path, 2, 3, 7)
-            await select_with_parameters(pool, full_path, 2, 3, 8)
+            await select_with_parameters(pool, 2, 3, 7)
+            await select_with_parameters(pool, 2, 3, 8)
 
-            await explicit_transaction_control(pool, full_path, 2, 6, 1)
-            await select_with_parameters(pool, full_path, 2, 6, 1)
-            await huge_select(pool, full_path)
+            await explicit_transaction_control(pool, 2, 6, 1)
+            await select_with_parameters(pool, 2, 6, 1)
+            await huge_select(pool)

From cc67aeece8088c0fbceee1c9a926a649933e9ede Mon Sep 17 00:00:00 2001
From: Oleg Ovcharuk <vgvoleg@gmail.com>
Date: Wed, 21 Aug 2024 12:59:49 +0300
Subject: [PATCH 3/3] review fixes

---
 examples/basic_example_v2/basic_example_async.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/examples/basic_example_v2/basic_example_async.py b/examples/basic_example_v2/basic_example_async.py
index e35fbabc..944ffe7c 100644
--- a/examples/basic_example_v2/basic_example_async.py
+++ b/examples/basic_example_v2/basic_example_async.py
@@ -138,9 +138,7 @@ async def select_with_parameters(pool: ydb.aio.QuerySessionPoolAsync, series_id,
 # In most cases it's better to use transaction control settings in session.transaction
 # calls instead to avoid additional hops to YDB cluster and allow more efficient
 # execution of queries.
-async def explicit_transaction_control(
-    pool: ydb.aio.QuerySessionPoolAsync, series_id, season_id, episode_id
-):
+async def explicit_transaction_control(pool: ydb.aio.QuerySessionPoolAsync, series_id, season_id, episode_id):
     async def callee(session: ydb.aio.QuerySessionAsync):
         query = """
         DECLARE $seriesId AS Int64;