kaqing 2.0.172__py3-none-any.whl → 2.0.186__py3-none-any.whl

adam/commands/export/exporter.py

@@ -1,21 +1,20 @@
 from datetime import datetime
-import functools
-import re
 import time
 
+from adam.commands.command import InvalidArgumentsException
 from adam.commands.cql.utils_cql import cassandra_table_names, run_cql, table_spec
-from adam.commands.export.export_databases import ExportDatabases
+from adam.commands.export.export_databases import export_db
+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
+from adam.commands.export.utils_export import ExportSpec, ExportTableStatus, ExportTableSpec, ImportSpec, csv_dir, find_files, state_with_pod
 from adam.config import Config
 from adam.pod_exec_result import PodExecResult
 from adam.repl_state import ReplState
-from adam.utils import debug, parallelize, log2, ing, log_exc
+from adam.utils import debug, log, 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.statefulsets import StatefulSets
 
 class Exporter:
     def export_tables(args: list[str], state: ReplState, export_only: bool = False, max_workers = 0) -> tuple[list[str], ExportSpec]:
@@ -69,10 +68,10 @@ class Exporter:
 
         return spec
 
-    def import_session(args: list[str], state: ReplState, max_workers = 0) -> tuple[list[str], ExportSpec]:
+    def import_session(spec_str: str, state: ReplState, max_workers = 0) -> tuple[list[str], ExportSpec]:
         import_spec: ImportSpec = None
         with log_exc(True):
-            import_spec = Exporter.import_spec(' '.join(args), state)
+            import_spec = Exporter.import_spec(spec_str, state)
             tables, status_in_whole = ExportTableStatus.from_session(state.sts, state.pod, state.namespace, import_spec.session)
             if status_in_whole == 'done':
                 log2(f'The session has been completely done - no more csv files are found.')
@@ -84,8 +83,30 @@ class Exporter:
 
         return [], None
 
-    def import_spec(spec_str: str, state: ReplState):
-        spec: ImportSpec = ImportSpec.parse_specs(spec_str)
+    def import_local_csv_files(spec_str: str, state: ReplState, max_workers = 0) -> tuple[list[str], ExportSpec]:
+        spec: ImportSpec = None
+        with log_exc(True):
+            spec = Exporter.import_spec(spec_str, state, files=True)
+            if not spec.table_name:
+                log2(f"Use 'as <database-name>.<table-name>'.")
+                raise InvalidArgumentsException()
+
+            d_t = spec.table_name.split('.')
+            if len(d_t) != 2:
+                log2(f'Need <database-name>.<table-name> format for target table.')
+                raise InvalidArgumentsException()
+
+            database = d_t[0]
+            table = d_t[1]
+            im = AthenaImporter() if spec.importer == 'athena' else SqliteImporter()
+
+            with parallelize(spec.files, max_workers, msg='Importing|Imported {size} csv files') as exec:
+                return exec.map(lambda f: im.import_from_local_csv(state, database, table, f, len(spec.files) > 1, True)), spec
+
+        return [], None
+
+    def import_spec(spec_str: str, state: ReplState, files = False):
+        spec: ImportSpec = ImportSpec.parse_specs(spec_str, files=files)
 
         session = state.export_session
         if session:
@@ -104,15 +125,19 @@ class Exporter:
             if not spec.importer:
                 spec.importer = Importer.importer_from_session(spec.session)
 
-            if spec.importer == 'csv':
+            if not spec.importer or spec.importer == 'csv':
                 spec.importer = Config().get('export.default-importer', 'sqlite')
 
             if spec.importer == 'athena' and not AthenaImporter.ping():
                 raise Exception('Credentials for Athena is not present.')
 
             prefix = Importer.prefix_from_importer(spec.importer)
-            session = f'{prefix}{spec.session[1:]}'
-            state.export_session = session
+            if spec.session:
+                spec.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
 
         return spec
 
@@ -196,7 +221,7 @@ class Exporter:
         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(), background=True, log_file=log_file),
+            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
@@ -211,109 +236,7 @@ class Exporter:
 
     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):
         im = AthenaImporter() if importer == 'athena' else SqliteImporter()
-        return im.import_from_csv(state.pod, state.namespace, state.export_session, session if session else state.export_session, spec.keyspace, table, target_table, columns, multi_tables, create_db)
-
-    def clear_export_session_cache():
-        Exporter.find_export_sessions.cache_clear()
-        Exporter.export_session_names.cache_clear()
-
-    @functools.lru_cache()
-    def export_session_names(sts: str, pod: str, namespace: str, importer: str = None, export_state = None):
-        if not sts or not namespace:
-            return []
-
-        if not pod:
-            pod = StatefulSets.pod_names(sts, namespace)[0]
-
-        if not pod:
-            return []
-
-        return [session for session, state in Exporter.find_export_sessions(pod, namespace, importer).items() if not export_state or state == export_state]
-
-    @functools.lru_cache()
-    def find_export_sessions(pod: str, namespace: str, importer: str = None, limit = 100):
-        sessions: dict[str, str] = {}
-
-        prefix = Importer.prefix_from_importer(importer)
-
-        log_files: list[str] = find_files(pod, namespace, f'{log_prefix()}-{prefix}*_*.log*')
-
-        if not log_files:
-            return {}
-
-        for log_file in log_files[:limit]:
-            m = re.match(f'{log_prefix()}-(.*?)_.*\.log?(.*)', log_file)
-            if m:
-                s = m.group(1)
-                state = m.group(2) # '', '.pending_import', '.done'
-                if state:
-                    state = state.strip('.')
-                else:
-                    state = 'in_export'
-
-                if s not in sessions:
-                    sessions[s] = state
-                elif sessions[s] == 'done' and state != 'done':
-                    sessions[s] = state
-
-        return sessions
-
-    def clean_up_all_sessions(sts: str, pod: str, namespace: str):
-        if not sts or not namespace:
-            return False
-
-        if not pod:
-            pod = StatefulSets.pod_names(sts, namespace)[0]
-
-        CassandraNodes.exec(pod, namespace, f'rm -rf {csv_dir()}/*', show_out=Config().is_debug(), shell='bash')
-        CassandraNodes.exec(pod, namespace, f'rm -rf {log_prefix()}-*.log*', show_out=Config().is_debug(), shell='bash')
-
-        return True
-
-    def clean_up_sessions(sts: str, pod: str, namespace: str, sessions: list[str], max_workers = 0):
-        if not sessions:
-            return []
-
-        if not max_workers:
-            max_workers = Config().action_workers('export', 8)
-
-        with parallelize(sessions, max_workers, msg='Cleaning|Cleaned up {size} export sessions') as exec:
-            cnt_tuples = exec.map(lambda session: Exporter.clean_up_session(sts, pod, namespace, session, True))
-            csv_cnt = 0
-            log_cnt = 0
-            for (csv, log) in cnt_tuples:
-                csv_cnt += csv
-                log_cnt += log
-
-            return csv_cnt, log_cnt
-
-    def clean_up_session(sts: str, pod: str, namespace: str, session: str, multi_tables = True):
-        if not sts or not namespace:
-            return 0, 0
-
-        if not pod:
-            pod = StatefulSets.pod_names(sts, namespace)[0]
-
-        if not pod:
-            return 0, 0
-
-        csv_cnt = 0
-        log_cnt = 0
-
-        log_files: list[str] = find_files(pod, namespace, f'{log_prefix()}-{session}_*.log*')
-
-        for log_file in log_files:
-            m = re.match(f'{log_prefix()}-{session}_(.*?)\.(.*?)\.log.*', log_file)
-            if m:
-                table = m.group(2)
-
-                CassandraNodes.exec(pod, namespace, f'rm -rf {csv_dir()}/{session}_{table}', show_out=not multi_tables, shell='bash')
-                csv_cnt += 1
-
-                CassandraNodes.exec(pod, namespace, f'rm -rf {log_file}', show_out=not multi_tables, shell='bash')
-                log_cnt += 1
-
-        return csv_cnt, log_cnt
+        return im.import_from_csv(state, session if session else state.export_session, spec.keyspace, table, target_table, columns, multi_tables, create_db)
 
     def resove_table_n_columns(spec: ExportTableSpec, state: ReplState, include_ks_in_target = False, importer = 'sqlite'):
         table = spec.table
@@ -339,15 +262,71 @@ class Exporter:
 
         return table, target_table, columns
 
-    def drop_databases(sts: str, pod: str, namespace: str, db: str = None):
-        importer = None
-        if db:
-            importer = Importer.importer_from_session(db)
-
-        sessions_done = Exporter.export_session_names(sts, pod, namespace, importer=importer, export_state='done')
-        sessions = ExportDatabases.sessions_from_dbs(ExportDatabases.drop_export_dbs(db))
-        if sessions_done and sessions:
-            intersects = list(set(sessions_done) & set(sessions))
-            with ing(f'Cleaning up {len(intersects)} completed sessions'):
-                Exporter.clean_up_sessions(sts, pod, namespace, list(intersects))
-                Exporter.clear_export_session_cache()
+class ExportService:
+    def __init__(self, handler: 'ExporterHandler'):
+        self.handler = handler
+
+    def export(self, args: list[str], export_only=False):
+        state = self.handler.state
+        export_session = state.export_session
+        spec: ExportSpec = None
+        try:
+            with state_with_pod(state) as state:
+                # --export-only for testing only
+                statuses, spec = Exporter.export_tables(args, state, export_only=export_only)
+                if not statuses:
+                    return state
+
+                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()
+        finally:
+            # 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
+
+        return state
+
+    def import_session(self, spec_str: str):
+        state = self.handler.state
+
+        tables, _ = Exporter.import_session(spec_str, state)
+        if tables:
+            ExportSessions.clear_export_session_cache()
+
+            log()
+            with export_db(state) as dbs:
+                dbs.show_database()
+
+        return state
+
+    def import_files(self, spec_str: str):
+        state = self.handler.state
+
+        tables, _ = Exporter.import_local_csv_files(spec_str, state)
+        if tables:
+            ExportSessions.clear_export_session_cache()
+
+            log()
+            with export_db(state) as dbs:
+                dbs.show_database()
+
+        return state
+
+class ExporterHandler:
+    def __init__(self, state: ReplState):
+        self.state = state
+
+    def __enter__(self):
+        return ExportService(self)
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return False
+
+def export(state: ReplState):
+    return ExporterHandler(state)

adam/commands/export/import_files.py

@@ -0,0 +1,44 @@
+from adam.commands import validate_args
+from adam.commands.command import Command
+from adam.commands.export.export_sessions import ExportSessions
+from adam.commands.export.exporter import export
+from adam.commands.export.utils_export import state_with_pod
+from adam.repl_state import ReplState, RequiredState
+
+class ImportCSVFiles(Command):
+    COMMAND = 'import files'
+
+    # the singleton pattern
+    def __new__(cls, *args, **kwargs):
+        if not hasattr(cls, 'instance'): cls.instance = super(ImportCSVFiles, cls).__new__(cls)
+
+        return cls.instance
+
+    def __init__(self, successor: Command=None):
+        super().__init__(successor)
+
+    def command(self):
+        return ImportCSVFiles.COMMAND
+
+    def required(self):
+        return RequiredState.CLUSTER_OR_POD
+
+    def run(self, cmd: str, state: ReplState):
+        if not(args := self.args(cmd)):
+            return super().run(cmd, state)
+
+        with self.validate(args, state) as (args, state):
+            with validate_args(args, state, name='file') as spec:
+                with state_with_pod(state) as state:
+                    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')
+
+        return {}
+
+    def help(self, _: ReplState):
+        return f'{ImportCSVFiles.COMMAND} <file-names,...>\t import files in session to Athena or SQLite'

adam/commands/export/import_session.py

@@ -1,6 +1,8 @@
+from adam.commands import validate_args
 from adam.commands.command import Command
-from adam.commands.export.export_handlers import export
-from adam.commands.export.exporter import Exporter
+from adam.commands.export.export_sessions import ExportSessions
+from adam.commands.export.exporter import export
+from adam.commands.export.utils_export import state_with_pod
 from adam.repl_state import ReplState, RequiredState
 
 class ImportSession(Command):
@@ -26,13 +28,15 @@ class ImportSession(Command):
             return super().run(cmd, state)
 
         with self.validate(args, state) as (args, state):
-            with export(state) as exporter:
-                return exporter.import_sesion(args)
+            with validate_args(args, state, name='export session') as spec:
+                with state_with_pod(state) as state:
+                    with export(state) as exporter:
+                        return exporter.import_session(spec)
 
     def completion(self, state: ReplState):
         # warm up cache
-        Exporter.export_session_names(state.sts, state.pod, state.namespace)
-        Exporter.export_session_names(state.sts, state.pod, state.namespace, export_state='pending_import')
+        # 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 {}
 

adam/commands/export/importer.py

@@ -2,6 +2,7 @@ from abc import abstractmethod
 
 from adam.commands.export.utils_export import csv_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
@@ -12,10 +13,20 @@ class Importer:
         pass
 
     @abstractmethod
-    def import_from_csv(self, pod: str, namespace: str, to_session: str, 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):
         pass
 
-    def move_to_done(self, pod: str, namespace: str, to_session: str, from_session: str, keyspace: str, target_table: str):
+    @abstractmethod
+    def import_from_local_csv(self, state: ReplState,
+                        keyspace: str, table: str, target_table: str, columns: str,
+                        csv_file: str,
+                        multi_tables = True, create_db = False):
+        pass
+
+    def move_to_done(self, state: ReplState, from_session: str, keyspace: str, target_table: str):
+        pod = state.pod
+        namespace = state.namespace
+        to_session = state.export_session
         log_file = f'{log_prefix()}-{from_session}_{keyspace}.{target_table}.log.pending_import'
 
         to = f'{log_prefix()}-{to_session}_{keyspace}.{target_table}.log.done'
@@ -30,9 +41,12 @@ class Importer:
 
         return session
 
-    def remove_csv(self, pod: str, namespace: str, session: str, table: str, target_table: str, multi_tables = True):
-        with ing(f'[{session}] Cleaning up temporary files', suppress_log=multi_tables):
-            CassandraNodes.exec(pod, namespace, f'rm -rf {self.csv_file(session, table, target_table)}', show_out=Config().is_debug(), shell='bash')
+    def remove_csv(self, state: ReplState, from_session: str, table: str, target_table: str, multi_tables = True):
+        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')
 
     def db(self, session: str, keyspace: str):
         return f'{session}_{keyspace}'

adam/commands/export/importer_athena.py

@@ -1,9 +1,11 @@
+import os
 import boto3
 
+from adam.commands.export.export_databases import export_db
 from adam.commands.export.importer import Importer
-from adam.commands.export.utils_export import GeneratorStream
 from adam.config import Config
-from adam.utils import debug, log2, ing
+from adam.repl_state import ReplState
+from adam.utils import GeneratorStream, bytes_generator_from_file, debug, log2, ing
 from adam.utils_athena import Athena
 from adam.utils_k8s.pods import Pods
 
@@ -17,9 +19,14 @@ class AthenaImporter(Importer):
     def prefix(self):
         return 'e'
 
-    def import_from_csv(self, pod: str, namespace: str, to_session: str, 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):
         csv_file = self.csv_file(from_session, table, target_table)
-        db = self.db(to_session, keyspace)
+        pod = state.pod
+        namespace = state.namespace
+        to_session = state.export_session
+        database = self.db(to_session, keyspace)
 
         succeeded = False
         try:
@@ -29,49 +36,113 @@ class AthenaImporter(Importer):
                 bytes = Pods.read_file(pod, 'cassandra', namespace, csv_file)
 
                 s3 = boto3.client('s3')
-                s3.upload_fileobj(GeneratorStream(bytes), bucket, f'export/{db}/{keyspace}/{target_table}/{table}.csv')
-
-            msg: str = None
-            if create_db:
-                msg = f"[{to_session}] Creating database {db}"
-            else:
-                msg = f"[{to_session}] Creating table {target_table}"
-            with ing(msg, suppress_log=multi_tables):
-                query = f'CREATE DATABASE IF NOT EXISTS {db};'
-                debug(query)
-                Athena.query(query, 'default')
-
-                query = f'DROP TABLE IF EXISTS {target_table};'
-                debug(query)
-                Athena.query(query, db)
-
-                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/{db}/{keyspace}/{target_table}'\n" + \
-                            'TBLPROPERTIES ("skip.header.line.count"="1");'
-                debug(query)
-                try:
-                    Athena.query(query, db)
-                except Exception as e:
-                    log2(f'*** Failed query:\n{query}')
-                    raise e
-
-            to, _ = self.move_to_done(pod, namespace, to_session, from_session, keyspace, target_table)
+                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)
+
+            to, _ = self.move_to_done(state, from_session, keyspace, target_table)
 
             succeeded = True
 
             return to, to_session
         finally:
             if succeeded:
-                self.remove_csv(pod, namespace, from_session, table, target_table, multi_tables)
+                self.remove_csv(state, from_session, table, target_table, multi_tables)
                 Athena.clear_cache()
 
                 if not multi_tables:
-                    query = f'select * from {target_table} limit 10'
-                    log2(query)
-                    Athena.run_query(query, db)
+                    with export_db(state) as dbs:
+                        dbs.sql(f'select * from {database}.{target_table} limit 10')
+
+    def import_from_local_csv(self, state: ReplState,
+                        keyspace: str, table: str, csv_file: str, multi_tables = True, create_db = False):
+        to_session = state.export_session
+        database = self.db(to_session, keyspace)
+
+        succeeded = False
+        try:
+            columns = None
+            with open(csv_file, 'r') as f:
+                columns = f.readline()
+
+            bucket = Config().get('export.bucket', 'c3.ops--qing')
+
+            with ing(f'[{to_session}] Uploading to S3', suppress_log=multi_tables):
+                bytes = bytes_generator_from_file(csv_file)
+
+                s3 = boto3.client('s3')
+                s3.upload_fileobj(GeneratorStream(bytes), bucket, f'export/{database}/{keyspace}/{table}/{os.path.basename(csv_file)}')
+
+            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
+
+            succeeded = True
+
+            return csv_file, to_session
+        finally:
+            if succeeded:
+                Athena.clear_cache()
+
+                if not multi_tables:
+                    with export_db(state) as dbs:
+                        dbs.sql(f'select * from {database}.{table} limit 10')
+
+    def create_schema(self, to_session: str, bucket: str, database: str, keyspace: str, table: str, columns: list[str], multi_tables: bool, create_db = False):
+        msg: str = None
+        if create_db:
+            msg = f"[{to_session}] Creating database {database}"
+        else:
+            msg = f"[{to_session}] Creating table {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 {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 {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}/{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