kaqing 2.0.184__py3-none-any.whl → 2.0.227__py3-none-any.whl

adam/commands/export/exporter.py

@@ -1,5 +1,6 @@
 from datetime import datetime
 import time
+import traceback
 
 from adam.commands.command import InvalidArgumentsException
 from adam.commands.cql.utils_cql import cassandra_table_names, run_cql, table_spec
@@ -8,13 +9,13 @@ from adam.commands.export.export_sessions import ExportSessions
 from adam.commands.export.importer import Importer
 from adam.commands.export.importer_athena import AthenaImporter
 from adam.commands.export.importer_sqlite import SqliteImporter
-from adam.commands.export.utils_export import ExportSpec, ExportTableStatus, ExportTableSpec, ImportSpec, csv_dir, find_files, state_with_pod
+from adam.commands.export.utils_export import ExportSpec, ExportTableStatus, ExportTableSpec, ImportSpec, csv_dir, fs_exec, state_with_pod, table_log_dir
 from adam.config import Config
-from adam.pod_exec_result import PodExecResult
+from adam.repl_session import ReplSession
 from adam.repl_state import ReplState
-from adam.utils import debug, log, parallelize, log2, ing, log_exc
+from adam.utils import debug, kaqing_log_file_name, log, log_to_pods, offload, parallelize, log2, ing, log_exc
 from adam.utils_k8s.cassandra_nodes import CassandraNodes
-from adam.utils_k8s.pods import log_prefix
+from adam.utils_k8s.pods import Pods
 
 class Exporter:
     def export_tables(args: list[str], state: ReplState, export_only: bool = False, max_workers = 0) -> tuple[list[str], ExportSpec]:
@@ -133,11 +134,9 @@ class Exporter:
 
             prefix = Importer.prefix_from_importer(spec.importer)
             if spec.session:
-                spec.session = f'{prefix}{spec.session[1:]}'
+                state.export_session = f'{prefix}{spec.session[1:]}'
             else:
-                spec.session = f'{prefix}{datetime.now().strftime("%Y%m%d%H%M%S")[3:]}'
-
-            state.export_session = spec.session
+                state.export_session = f'{prefix}{datetime.now().strftime("%Y%m%d%H%M%S")[3:]}'
 
         return spec
 
@@ -154,89 +153,160 @@ class Exporter:
         if export_state == 'init':
             CassandraNodes.exec(state.pod, state.namespace, f'rm -rf {csv_dir()}/{spec.session}_*', show_out=Config().is_debug(), shell='bash')
 
-        action = f'[{spec.session}] Exporting|Exported'
+        job_log = kaqing_log_file_name()
+
+        action = f'[{spec.session}] Triggering export of'
         if export_state == 'init':
             action = f'[{spec.session}] Preparing|Prepared'
         elif export_state == 'import':
             action = f'[{spec.session}] Importing|Imported'
 
-        with parallelize(spec.tables, max_workers, msg=action + ' {size} Cassandra tables') as exec:
-            return exec.map(lambda table: Exporter.export_table(table, state, spec.session, spec.importer, export_only, len(spec.tables) > 1, consistency=spec.consistency, export_state=export_state)), spec
-
-    def export_table(spec: ExportTableSpec, state: ReplState, session: str, importer: str, export_only = False, multi_tables = True, consistency: str = None, export_state=None):
+        msg = action + ' {size} Cassandra tables'
+
+        if export_state != 'init':
+            log2(f'[{spec.session}] Logging to {job_log}...')
+            ReplSession().append_history(f':cat {job_log}')
+
+        pod = state.pod
+        with parallelize(spec.tables, max_workers, msg=msg, collect=export_state == 'init', name='exporter') as exec:
+            return exec.map(lambda table: Exporter.export_table(table,
+                                                                state.with_pod(pod),
+                                                                spec.session,
+                                                                spec.importer,
+                                                                export_only,
+                                                                len(spec.tables) > 1,
+                                                                consistency=spec.consistency,
+                                                                export_state=export_state,
+                                                                job_log=None if export_state == 'init' else job_log)), spec
+
+    def export_table(spec: ExportTableSpec,
+                     state: ReplState,
+                     session: str,
+                     importer: str,
+                     export_only = False,
+                     multi_tables = True,
+                     consistency: str = None,
+                     export_state=None,
+                     job_log: str = None):
         s: str = None
 
         table, target_table, columns = Exporter.resove_table_n_columns(spec, state, include_ks_in_target=False, importer=importer)
 
-        log_file = f'{log_prefix()}-{session}_{spec.keyspace}.{target_table}.log'
+        log_file = f'{table_log_dir(state.pod, state.namespace)}/{session}_{spec.keyspace}.{target_table}.log'
         create_db = not state.export_session
 
         if export_state == 'init':
             Exporter.create_table_log(spec, state, session, table, target_table)
             return 'table_log_created'
         else:
-            if export_state == 'pending_export':
-                Exporter.export_to_csv(spec, state, session, table, target_table, columns, multi_tables=multi_tables, consistency=consistency)
+            try:
+                if export_state == 'pending_export':
+                    Exporter.export_to_csv(spec, state, session, table, target_table, columns, multi_tables=multi_tables, consistency=consistency, job_log=job_log)
 
-            log_files: list[str] = find_files(state.pod, state.namespace, f'{log_file}*')
-            if not log_files:
-                return s
+                log_files: list[str] = Pods.find_files(state.pod, 'cassandra', state.namespace, f'{log_file}*', remote=log_to_pods())
+                if not log_files:
+                    return s
 
-            log_file = log_files[0]
+                log_file = log_files[0]
 
-            status: ExportTableStatus = ExportTableStatus.from_log_file(state.pod, state.namespace, session, log_file)
-            while status.status != 'done':
-                if status.status == 'export_in_pregress':
-                    debug('Exporting to CSV is still in progess, sleeping for 1 sec...')
-                    time.sleep(1)
-                elif status.status == 'exported':
-                    log_file = Exporter.rename_to_pending_import(spec, state, session, target_table)
-                    if importer == 'csv' or export_only:
-                        return 'pending_import'
-                elif status.status == 'pending_import':
-                    log_file, session = Exporter.import_from_csv(spec, state, session, importer, table, target_table, columns, multi_tables=multi_tables, create_db=create_db)
+                status: ExportTableStatus = ExportTableStatus.from_log_file(state.pod, state.namespace, session, log_file)
 
-                status = ExportTableStatus.from_log_file(state.pod, state.namespace, session, log_file)
+                with offload(name='exporter') as exec:
+                    ctx = ExportTableContext(spec, state, session, importer, export_only, multi_tables, table, target_table, columns, create_db, log_file, status, job_log)
+                    exec.submit(lambda: Exporter.export_loop(ctx))
+                # Exporter.export_loop(ExportTableContext(spec, state, session, importer, export_only, multi_tables, table, target_table, columns, create_db, log_file, status))
+            except:
+                traceback.print_exc()
 
             return status.status
 
+    def export_loop(ctx: 'ExportTableContext'):
+        try:
+            while ctx.status.status != 'done':
+                if ctx.status.status == 'export_in_pregress':
+                    debug('Exporting to CSV is still in progess, sleeping for 1 sec...')
+                    time.sleep(1)
+                elif ctx.status.status == 'exported':
+                    ctx.log_file = Exporter.rename_to_pending_import(ctx.spec, ctx.state, ctx.session, ctx.target_table)
+                    ExportSessions.clear_export_session_cache()
+                    if ctx.importer == 'csv' or ctx.export_only:
+                        return 'pending_import'
+                elif ctx.status.status == 'pending_import':
+                    ctx.log_file, ctx.session = Exporter.import_from_csv(ctx.spec,
+                                                                         ctx.state,
+                                                                         ctx.session,
+                                                                         ctx.importer,
+                                                                         ctx.table,
+                                                                         ctx.target_table,
+                                                                         ctx.columns,
+                                                                         multi_tables=ctx.multi_tables,
+                                                                         create_db=ctx.create_db,
+                                                                         job_log=ctx.f)
+
+                ctx.status = ExportTableStatus.from_log_file(ctx.state.pod, ctx.state.namespace, ctx.session, ctx.log_file)
+
+            return ctx.status.status
+        except:
+            traceback.print_exc()
+
     def create_table_log(spec: ExportTableSpec, state: ReplState, session: str, table: str, target_table: str):
-        log_file = f'{log_prefix()}-{session}_{spec.keyspace}.{target_table}.log'
+        dir = table_log_dir(state.pod, state.namespace)
+        log_file = f'{dir}/{session}_{spec.keyspace}.{target_table}.log'
 
-        CassandraNodes.exec(state.pod, state.namespace, f'rm -f {log_file}* && touch {log_file}', show_out=Config().is_debug(), shell='bash')
+        cmd = f'rm -f {log_file}* && mkdir -p {dir} && touch {log_file}'
+        fs_exec(state.pod, state.namespace, cmd, show_out=Config().is_debug())
 
         return table
 
-    def export_to_csv(spec: ExportTableSpec, state: ReplState, session: str, table: str, target_table: str, columns: str, multi_tables = True, consistency: str = None):
+    def export_to_csv(spec: ExportTableSpec,
+                      state: ReplState,
+                      session: str,
+                      table: str,
+                      target_table: str,
+                      columns: str,
+                      multi_tables = True,
+                      consistency: str = None,
+                      job_log: str = None):
         db = f'{session}_{target_table}'
 
         CassandraNodes.exec(state.pod, state.namespace, f'mkdir -p {csv_dir()}/{db}', show_out=Config().is_debug(), shell='bash')
         csv_file = f'{csv_dir()}/{db}/{table}.csv'
-        log_file = f'{log_prefix()}-{session}_{spec.keyspace}.{target_table}.log'
+        table_log_file = f'{table_log_dir(state.pod, state.namespace)}/{session}_{spec.keyspace}.{target_table}.log'
 
         suppress_ing_log = Config().is_debug() or multi_tables
         queries = []
         if consistency:
             queries.append(f'CONSISTENCY {consistency}')
         queries.append(f"COPY {spec.keyspace}.{table}({columns}) TO '{csv_file}' WITH HEADER = TRUE")
-        r: PodExecResult = ing(
-            f'[{session}] Dumping table {spec.keyspace}.{table}{f" with consistency {consistency}" if consistency else ""}',
-            lambda: run_cql(state, ';'.join(queries), show_out=Config().is_debug(), backgrounded=True, log_file=log_file),
-            suppress_log=suppress_ing_log)
 
-        return log_file
+        with ing(f'[{session}] Triggering dump of table {spec.keyspace}.{table}{f" with consistency {consistency}" if consistency else ""}',
+                 suppress_log=suppress_ing_log,
+                 job_log = job_log):
+            run_cql(state, ';'.join(queries), show_out=Config().is_debug(), backgrounded=True, log_file=table_log_file, history=False)
+
+        return table_log_file
 
     def rename_to_pending_import(spec: ExportTableSpec, state: ReplState, session: str, target_table: str):
-        log_file = f'{log_prefix()}-{session}_{spec.keyspace}.{target_table}.log'
+        log_file = f'{table_log_dir(state.pod, state.namespace)}/{session}_{spec.keyspace}.{target_table}.log'
         to = f'{log_file}.pending_import'
 
-        CassandraNodes.exec(state.pod, state.namespace, f'mv {log_file} {to}', show_out=Config().is_debug(), shell='bash')
+        cmd =f'mv {log_file} {to}'
+        fs_exec(state.pod, state.namespace, cmd, show_out=Config().is_debug())
 
         return to
 
-    def import_from_csv(spec: ExportTableSpec, state: ReplState, session: str, importer: str, table: str, target_table: str, columns: str, multi_tables = True, create_db = False):
+    def import_from_csv(spec: ExportTableSpec,
+                        state: ReplState,
+                        session: str,
+                        importer: str,
+                        table: str,
+                        target_table: str,
+                        columns: str,
+                        multi_tables = True,
+                        create_db = False,
+                        job_log: str = None):
         im = AthenaImporter() if importer == 'athena' else SqliteImporter()
-        return im.import_from_csv(state, session if session else state.export_session, spec.keyspace, table, target_table, columns, multi_tables, create_db)
+        return im.import_from_csv(state, session if session else state.export_session, spec.keyspace, table, target_table, columns, multi_tables, create_db, job_log=job_log)
 
     def resove_table_n_columns(spec: ExportTableSpec, state: ReplState, include_ks_in_target = False, importer = 'sqlite'):
         table = spec.table
@@ -262,6 +332,22 @@ class Exporter:
 
         return table, target_table, columns
 
+class ExportTableContext:
+    def __init__(self, spec: ExportTableSpec, state: ReplState, session: str, importer: str, export_only = False, multi_tables = True, table: str = None, target_table: str = None, columns: str = None, create_db = False, log_file: str = None, status: ExportTableStatus = None, f: str = None):
+        self.spec = spec
+        self.state = state
+        self.session = session
+        self.importer = importer
+        self.export_only = export_only
+        self.multi_tables = multi_tables
+        self.table = table
+        self.target_table = target_table
+        self.columns = columns
+        self.create_db = create_db
+        self.log_file = log_file
+        self.status = status
+        self.f = f
+
 class ExportService:
     def __init__(self, handler: 'ExporterHandler'):
         self.handler = handler
@@ -279,16 +365,17 @@ class ExportService:
 
                 ExportSessions.clear_export_session_cache()
 
-                if spec.importer == 'csv' or export_only:
-                    ExportSessions.show_session(state.sts, state.pod, state.namespace, spec.session)
-                else:
-                    log()
-                    with export_db(state) as dbs:
-                        dbs.show_database()
+                # if spec.importer == 'csv' or export_only:
+                #     ExportSessions.show_session(state.sts, state.pod, state.namespace, spec.session)
+                # else:
+                #     log()
+                #     with export_db(state) as dbs:
+                #         dbs.show_database()
         finally:
+            pass
             # if exporting to csv, do not bind the new session id to repl state
-            if spec and spec.importer == 'csv':
-                state.export_session = export_session
+            # if spec and spec.importer == 'csv':
+            #     state.export_session = export_session
 
         return state
 

adam/commands/export/import_files.py

@@ -33,12 +33,8 @@ class ImportCSVFiles(Command):
                     with export(state) as exporter:
                         return exporter.import_files(spec)
 
-    def completion(self, state: ReplState):
-        # warm up cache
-        ExportSessions.export_session_names(state.sts, state.pod, state.namespace)
-        ExportSessions.export_session_names(state.sts, state.pod, state.namespace, export_state='pending_import')
-
+    def completion(self, _: ReplState):
         return {}
 
-    def help(self, _: ReplState):
-        return f'{ImportCSVFiles.COMMAND} <file-names,...>\t import files in session to Athena or SQLite'
+    def help(self, state: ReplState):
+        return super().help(state, 'import files in session to SQLite(or Athena)', args='<file-names>,...')

adam/commands/export/import_session.py

@@ -34,11 +34,7 @@ class ImportSession(Command):
                         return exporter.import_session(spec)
 
     def completion(self, state: ReplState):
-        # warm up cache
-        ExportSessions.export_session_names(state.sts, state.pod, state.namespace)
-        ExportSessions.export_session_names(state.sts, state.pod, state.namespace, export_state='pending_import')
-
         return {}
 
-    def help(self, _: ReplState):
-        return f'{ImportSession.COMMAND} <export-session-name>\t import files in session to Athena or SQLite'
+    def help(self, state: ReplState):
+        return super().help(state, 'import tables in session to SQLite(or Athena)', args='<export-session-name>')

adam/commands/export/importer.py

@@ -1,11 +1,9 @@
 from abc import abstractmethod
 
-from adam.commands.export.utils_export import csv_dir
+from adam.commands.export.utils_export import csv_dir, fs_exec, table_log_dir
 from adam.config import Config
 from adam.repl_state import ReplState
 from adam.utils import ing
-from adam.utils_k8s.cassandra_nodes import CassandraNodes
-from adam.utils_k8s.pods import log_prefix
 
 class Importer:
     @abstractmethod
@@ -13,7 +11,7 @@ class Importer:
         pass
 
     @abstractmethod
-    def import_from_csv(self, state: ReplState, from_session: str, keyspace: str, table: str, target_table: str, columns: str, multi_tables = True, create_db = False):
+    def import_from_csv(self, state: ReplState, from_session: str, keyspace: str, table: str, target_table: str, columns: str, multi_tables = True, create_db = False, log_file: str = None):
         pass
 
     @abstractmethod
@@ -24,14 +22,14 @@ class Importer:
         pass
 
     def move_to_done(self, state: ReplState, from_session: str, keyspace: str, target_table: str):
-        pod = state.pod
-        namespace = state.namespace
+        dir = table_log_dir(state.pod, state.namespace)
         to_session = state.export_session
-        log_file = f'{log_prefix()}-{from_session}_{keyspace}.{target_table}.log.pending_import'
+        log_file = f'{dir}/{from_session}_{keyspace}.{target_table}.log.pending_import'
 
-        to = f'{log_prefix()}-{to_session}_{keyspace}.{target_table}.log.done'
+        to = f'{dir}/{to_session}_{keyspace}.{target_table}.log.done'
 
-        CassandraNodes.exec(pod, namespace, f'mv {log_file} {to}', show_out=Config().is_debug(), shell='bash')
+        cmd = f'mv {log_file} {to}'
+        fs_exec(state.pod, state.namespace, cmd, show_out=Config().is_debug())
 
         return to, to_session
 
@@ -41,12 +39,13 @@ class Importer:
 
         return session
 
-    def remove_csv(self, state: ReplState, from_session: str, table: str, target_table: str, multi_tables = True):
+    def remove_csv(self, state: ReplState, from_session: str, table: str, target_table: str, multi_tables = True, job_log: str = None):
         pod = state.pod
         namespace = state.namespace
 
-        with ing(f'[{from_session}] Cleaning up temporary files', suppress_log=multi_tables):
-            CassandraNodes.exec(pod, namespace, f'rm -rf {self.csv_file(from_session, table, target_table)}', show_out=Config().is_debug(), shell='bash')
+        with ing(f'[{from_session}] Cleaning up temporary files', suppress_log=multi_tables, job_log=job_log):
+            cmd = f'rm -rf {self.csv_file(from_session, table, target_table)}'
+            fs_exec(state.pod, state.namespace, cmd, show_out=Config().is_debug())
 
     def db(self, session: str, keyspace: str):
         return f'{session}_{keyspace}'
@@ -78,4 +77,4 @@ class Importer:
         elif session.startswith('e'):
             importer = 'athena'
 
-        return importer
+        return importer

adam/commands/export/importer_athena.py

@@ -19,9 +19,16 @@ class AthenaImporter(Importer):
     def prefix(self):
         return 'e'
 
-    def import_from_csv(self, state: ReplState, from_session: str,
-                        keyspace: str, table: str, target_table: str, columns: str,
-                        multi_tables = True, create_db = False):
+    def import_from_csv(self,
+                        state: ReplState,
+                        from_session: str,
+                        keyspace: str,
+                        table: str,
+                        target_table: str,
+                        columns: str,
+                        multi_tables = True,
+                        create_db = False,
+                        job_log: str = None):
         csv_file = self.csv_file(from_session, table, target_table)
         pod = state.pod
         namespace = state.namespace
@@ -39,35 +46,6 @@ class AthenaImporter(Importer):
                 s3.upload_fileobj(GeneratorStream(bytes), bucket, f'export/{database}/{keyspace}/{target_table}/{table}.csv')
 
             self.create_schema(to_session, bucket, database, keyspace, table, columns, multi_tables, create_db)
-            # msg: str = None
-            # if create_db:
-            #     msg = f"[{to_session}] Creating database {database}"
-            # else:
-            #     msg = f"[{to_session}] Creating table {target_table}"
-            # with ing(msg, suppress_log=multi_tables):
-            #     query = f'CREATE DATABASE IF NOT EXISTS {database};'
-            #     debug(query)
-            #     Athena.query(query, 'default')
-
-            #     query = f'DROP TABLE IF EXISTS {target_table};'
-            #     debug(query)
-            #     Athena.query(query, database)
-
-            #     athena_columns = ', '.join([f'{c} string' for c in columns.split(',')])
-            #     query = f'CREATE EXTERNAL TABLE IF NOT EXISTS {target_table}(\n' + \
-            #             f'    {athena_columns})\n' + \
-            #                 "ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.OpenCSVSerde'\n" + \
-            #                 'WITH SERDEPROPERTIES (\n' + \
-            #                 '    "separatorChar" = ",",\n' + \
-            #                 '    "quoteChar"     = "\\"")\n' + \
-            #             f"LOCATION 's3://{bucket}/export/{database}/{keyspace}/{target_table}'\n" + \
-            #                 'TBLPROPERTIES ("skip.header.line.count"="1");'
-            #     debug(query)
-            #     try:
-            #         Athena.query(query, database)
-            #     except Exception as e:
-            #         log2(f'*** Failed query:\n{query}')
-            #         raise e
 
             to, _ = self.move_to_done(state, from_session, keyspace, target_table)
 
@@ -76,12 +54,14 @@ class AthenaImporter(Importer):
             return to, to_session
         finally:
             if succeeded:
-                self.remove_csv(state, from_session, table, target_table, multi_tables)
+                self.remove_csv(state, from_session, table, target_table, multi_tables, job_log=job_log)
                 Athena.clear_cache()
 
-                if not multi_tables:
+                if multi_tables:
+                    log2(f'[{to_session}] {keyspace}.{target_table} OK', file=job_log)
+                else:
                     with export_db(state) as dbs:
-                        dbs.sql(f'select * from {database}.{target_table} limit 10')
+                        dbs.sql(f'select * from {keyspace}.{target_table} limit 10', backgrounded=True, export_log=job_log)
 
     def import_from_local_csv(self, state: ReplState,
                         keyspace: str, table: str, csv_file: str, multi_tables = True, create_db = False):

adam/commands/export/importer_sqlite.py

@@ -1,9 +1,10 @@
+from typing import TextIO
 import pandas
 
 from adam.commands.export.export_databases import export_db
 from adam.commands.export.importer import Importer
 from adam.repl_state import ReplState
-from adam.utils import GeneratorStream, bytes_generator_from_file, ing
+from adam.utils import GeneratorStream, bytes_generator_from_file, ing, log2
 from adam.utils_k8s.pods import Pods
 from adam.utils_sqlite import SQLite, sqlite
 
@@ -11,9 +12,17 @@ class SqliteImporter(Importer):
     def prefix(self):
         return 's'
 
-    def import_from_csv(self, state: ReplState, from_session: str,
-                        keyspace: str, table: str, target_table: str, columns: str,
-                        multi_tables = True, create_db = False):
+    def import_from_csv(self,
+                        state: ReplState,
+                        from_session: str,
+                        keyspace: str,
+                        table: str,
+                        target_table: str,
+                        columns: str,
+                        multi_tables = True,
+                        create_db = False,
+                        job_log: str = None):
+
         csv_file = self.csv_file(from_session, table, target_table)
         pod = state.pod
         namespace = state.namespace
@@ -21,7 +30,7 @@ class SqliteImporter(Importer):
 
         succeeded = False
         try:
-            with ing(f'[{to_session}] Uploading to Sqlite', suppress_log=multi_tables):
+            with ing(f'[{to_session}] Uploading to Sqlite', suppress_log=multi_tables, job_log=job_log):
                 # create a connection to single keyspace
                 with sqlite(to_session, keyspace) as conn:
                     bytes = Pods.read_file(pod, 'cassandra', namespace, csv_file)
@@ -35,12 +44,14 @@ class SqliteImporter(Importer):
             return to, to_session
         finally:
             if succeeded:
-                self.remove_csv(state, from_session, table, target_table, multi_tables)
+                self.remove_csv(state, from_session, table, target_table, multi_tables, job_log=job_log)
                 SQLite.clear_cache()
 
-                if not multi_tables:
+                if multi_tables:
+                    log2(f'[{to_session}] {keyspace}.{target_table} OK', file=job_log)
+                else:
                     with export_db(state) as dbs:
-                        dbs.sql(f'select * from {keyspace}.{target_table} limit 10')
+                        dbs.sql(f'select * from {keyspace}.{target_table} limit 10', backgrounded=True, export_log=job_log)
 
     def import_from_local_csv(self, state: ReplState,
                         keyspace: str, table: str, csv_file: str, multi_tables = True, create_db = False):

adam/commands/export/show_column_counts.py

@@ -1,5 +1,6 @@
-from adam.commands import validate_args
+from adam.commands import extract_trailing_options, validate_args
 from adam.commands.command import Command
+from adam.commands.cql.utils_cql import cassandra_table_names
 from adam.commands.export.export_databases import ExportDatabases, export_db
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
@@ -27,19 +28,17 @@ class ShowColumnCounts(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            with validate_args(args, state, name='SQL statement') as table:
-                with export_db(state) as dbs:
-                    query = Config().get(f'export.column_counts_query', 'select id, count(id) as columns from {table} group by id')
-                    query = query.replace('{table}', table)
-                    dbs.sql(query, state.export_session)
+            with extract_trailing_options(args, '&') as (args, backgrounded):
+                with validate_args(args, state, name='SQL statement') as table:
+                    with export_db(state) as dbs:
+                        query = Config().get(f'export.column_counts_query', 'select id, count(id) as columns from {table} group by id')
+                        query = query.replace('{table}', table)
+                        dbs.sql(query, state.export_session, backgrounded=backgrounded)
 
             return state
 
     def completion(self, state: ReplState):
-        if not state.export_session:
-            return {}
+        return super().completion(state, lambda: {t: None for t in ExportDatabases.table_names(state.export_session)}, auto_key='x.tables')
 
-        return super().completion(state, lambda: {t: None for t in ExportDatabases.table_names(state.export_session)})
-
-    def help(self, _: ReplState):
-        return f'{ShowColumnCounts.COMMAND} <export-table-name>\t show column count per id'
+    def help(self, state: ReplState):
+        return super().help(state, 'show column count per id', args='<export-table-name>')

adam/commands/export/show_export_databases.py

@@ -31,8 +31,8 @@ class ShowExportDatabases(Command):
 
             return state
 
-    def completion(self, state: ReplState):
-        return DeviceExport().ls_completion(ShowExportDatabases.COMMAND, state, default = super().completion(state))
+    def completion(self, _: ReplState):
+        return {}
 
-    def help(self, _: ReplState):
-        return f'{ShowExportDatabases.COMMAND}\t list export databases'
+    def help(self, state: ReplState):
+        return super().help(state, 'list export databases')

adam/commands/export/show_export_session.py

@@ -1,6 +1,6 @@
 from adam.commands import validate_args
 from adam.commands.command import Command
-from adam.commands.export.export_sessions import ExportSessions, export_session
+from adam.commands.export.export_sessions import export_session
 from adam.repl_state import ReplState, RequiredState
 
 class ShowExportSession(Command):
@@ -32,8 +32,8 @@ class ShowExportSession(Command):
 
             return state
 
-    def completion(self, state: ReplState):
-        return super().completion(state, {session: None for session in ExportSessions.export_session_names(state.sts, state.pod, state.namespace)})
+    def completion(self, _: ReplState):
+        return {}
 
-    def help(self, _: ReplState):
-        return f'{ShowExportSession.COMMAND} <export-session-name>\t show export session'
+    def help(self, state: ReplState):
+        return super().help(state, 'show export session', args='<export-session-name>')

adam/commands/export/show_export_sessions.py

@@ -30,8 +30,8 @@ class ShowExportSessions(Command):
 
             return state
 
-    def completion(self, state: ReplState):
-        return super().completion(state)
+    def completion(self, _: ReplState):
+        return {}
 
-    def help(self, _: ReplState):
-        return f'{ShowExportSessions.COMMAND}\t list export sessions'
+    def help(self, state: ReplState):
+        return super().help(state, 'list export sessions')