kaqing 2.0.50__py3-none-any.whl → 2.0.51__py3-none-any.whl

adam/commands/cql/cql_completions.py

@@ -1,13 +1,11 @@
-from adam.commands.cql.cql_table_completer import CqlTableNameCompleter
 from adam.commands.cql.cql_utils import table_names
 from adam.repl_state import ReplState
 from adam.sql.sql_completer import SqlCompleter
 
 def cql_completions(state: ReplState) -> dict[str, any]:
-    table_name_completer = CqlTableNameCompleter(table_names(state))
     return {
         'describe': {
             'keyspaces': None,
-            'table': table_name_completer,
+            'table': {t: None for t in table_names(state)},
             'tables': None},
-    } | SqlCompleter.completions(table_name_completer)
+    } | SqlCompleter.completions(lambda: table_names(state))

adam/commands/cql/cql_table_completer.py

@@ -1,16 +1,8 @@
-from adam.sql.table_name_completer import NestedDict, TableNameCompleter
+from adam.sql.term_completer import TermCompleter
 
-class CqlTableNameCompleter(TableNameCompleter):
-    def __init__(self, tables: list[str], nested_dict: NestedDict = {}, ignore_case: bool = True):
-        self._tables = tables
-        self.ignore_case = ignore_case
-        self.append_nested_dict(nested_dict)
+class CqlTableNameCompleter(TermCompleter):
+    def __init__(self, tables: list[str], ignore_case: bool = True):
+        super().__init__(tables, ignore_case=ignore_case)
 
     def __repr__(self) -> str:
-        return "CqlTableCompleter(%r)" % (len(self._tables))
-
-    def nested(self, data: NestedDict) -> 'TableNameCompleter':
-        return CqlTableNameCompleter(self._tables).append_nested_dict(data)
-
-    def tables(self) -> list[str]:
-        return self._tables
+        return "CqlTableCompleter(%r)" % (len(self.words))

adam/commands/postgres/psql_completions.py

@@ -1,4 +1,4 @@
-from adam.commands.postgres.psql_table_completer import PsqlTableNameCompleter
+from adam.commands.postgres.postgres_utils import pg_table_names
 from adam.sql.sql_completer import SqlCompleter
 
 def psql_completions(ns: str, pg_path: str):
@@ -7,5 +7,4 @@ def psql_completions(ns: str, pg_path: str):
         '\d': None,
         '\dt': None,
         '\du': None
-    } | SqlCompleter.completions(PsqlTableNameCompleter(ns, pg_path))
-    # } | PsqlTableCompleter(ns, pg_path).completions()
+    } | SqlCompleter.completions(lambda: pg_table_names(ns, pg_path))

adam/commands/postgres/psql_table_completer.py

@@ -1,18 +1,11 @@
 from adam.commands.postgres.postgres_utils import pg_table_names
-from adam.sql.table_name_completer import NestedDict, TableNameCompleter
+from adam.sql.term_completer import TermCompleter
 
-class PsqlTableNameCompleter(TableNameCompleter):
-    def __init__(self, namespace: str, pg_path: str, nested_dict: NestedDict = {}, ignore_case: bool = True):
+class PsqlTableNameCompleter(TermCompleter):
+    def __init__(self, namespace: str, pg_path: str, ignore_case: bool = True):
+        super().__init__(pg_table_names(namespace, pg_path), ignore_case=ignore_case)
         self.namespace = namespace
         self.pg_path = pg_path
-        self.ignore_case = ignore_case
-        self.append_nested_dict(nested_dict)
 
     def __repr__(self) -> str:
-        return "PsqlTableCompleter(%r, pg_path=%r)" % (self.namespace, self.pg_path)
-
-    def nested(self, data: NestedDict) -> 'TableNameCompleter':
-        return PsqlTableNameCompleter(self.namespace, self.pg_path).append_nested_dict(data)
-
-    def tables(self) -> list[str]:
-        return pg_table_names(self.namespace, self.pg_path)
+        return "PsqlTableCompleter(%r, pg_path=%r)" % (self.namespace, self.pg_path)

adam/commands/preview_table.py

@@ -3,8 +3,8 @@ import functools
 from adam.commands.command import Command
 from adam.commands.cql.cql_table_completer import CqlTableNameCompleter
 from adam.commands.cql.cql_utils import run_cql, table_names, tables
-from adam.commands.postgres.psql_table_completer import PsqlTableNameCompleter
 from adam.commands.postgres.postgres_session import PostgresSession
+from adam.commands.postgres.psql_table_completer import PsqlTableNameCompleter
 from adam.config import Config
 from adam.repl_state import ReplState, RequiredState
 from adam.utils import lines_to_tabular, log, log2

adam/repl.py

@@ -18,7 +18,6 @@ from adam.log import Log
 from adam.repl_commands import ReplCommands
 from adam.repl_session import ReplSession
 from adam.repl_state import ReplState
-from adam.sql.sql_completer import SqlCompleter
 from adam.utils import deep_merge_dicts, deep_sort_dict, lines_to_tabular, log2
 from adam.apps import Apps
 from . import __version__
@@ -109,7 +108,7 @@ def enter_repl(state: ReplState):
                             log2(f'Timing auto-completion-calc {cmd.command()}: {time.time() - s1:.2f}')
 
                 # print(json.dumps(completions, indent=4))
-                completer = SqlCompleter.from_nested_dict(completions)
+                completer = NestedCompleter.from_nested_dict(completions)
 
             cmd = session.prompt(prompt_msg(), completer=completer, key_bindings=kb)
             s0 = time.time()

adam/sql/sql_completer.py

@@ -1,53 +1,403 @@
-from typing import Dict, Iterable, Optional
-from prompt_toolkit.completion import CompleteEvent, Completer, Completion, NestedCompleter, WordCompleter
+from typing import Callable, Iterable
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion
 from prompt_toolkit.document import Document
+import sqlparse
+from sqlparse.sql import Statement, Token
+from sqlparse import tokens as T
 
-from adam.sql.any_completer import AnyCompleter as any
-from adam.sql.sql_utils import safe_terms
-from adam.sql.table_name_completer import TableNameCompleter
+from adam.sql.term_completer import TermCompleter
 
-class SqlCompleter(NestedCompleter):
-    def __init__(
-        self, options: Dict[str, Optional[Completer]], ignore_case: bool = True
-    ) -> None:
-        super().__init__(options, ignore_case)
+class SqlCompleter(Completer):
+    def __init__(self, tables: Callable[[], list[str]], dml: str = None, debug = False):
+        super().__init__()
+        self.dml = dml
+        self.tables = tables
+        self.debug = debug
 
     def get_completions(
         self, document: Document, complete_event: CompleteEvent
     ) -> Iterable[Completion]:
         text = document.text_before_cursor.lstrip()
-        stripped_len = len(document.text_before_cursor) - len(text)
+        if self.dml:
+            state = f'{self.dml}_'
+            text = f'{self.dml} {text}'
 
-        terms, has_space = safe_terms(text)
-        if has_space:
-            first_term = terms[0]
-            completer = self.options.get(first_term)
+        completer = None
+        stmts = sqlparse.parse(text)
+        if not stmts:
+            completer = TermCompleter(['select', 'insert', 'delete', 'update'])
+        else:
+            statement: Statement = stmts[0]
+            state = self.traverse_tokens(text, statement.tokens)
+            if self.debug:
+                print('\n  =>', state)
+            if state == 'dml_incomplete':
+                completer = TermCompleter(['select', 'insert', 'delete', 'update'])
 
-            if completer is not None:
-                remaining_text = text[len(first_term) :].lstrip()
-                move_cursor = len(text) - len(remaining_text) + stripped_len
+            elif state == 'select_':
+                completer = TermCompleter(['*'])
+            elif state == 'select_a':
+                completer = TermCompleter(['from'])
+            elif state == 'select_a,':
+                completer = TermCompleter(['*'])
+            elif state == 'select_a_':
+                completer = TermCompleter(['from'])
+            elif state == "select_a_from_":
+                completer = TermCompleter(self.tables())
+            elif state == "select_a_from_x_":
+                completer = TermCompleter(['where', 'group', 'limit'])
+            elif state == "select_a_from_x,":
+                completer = TermCompleter(self.tables())
+            elif state == "select_a_from_x_where_":
+                completer = TermCompleter(['id'])
+            elif state == "select_a_from_x_where_id":
+                completer = TermCompleter(['=', '<', '<=', '>', '>=', '<>', 'like'])
+            elif state == "select_a_from_x_where_id=":
+                completer = TermCompleter(["'"])
+            elif state == "select_a_from_x_where_id=v_":
+                completer = TermCompleter(['and', 'or', 'group', 'limit'])
+            elif state == "select_a_from_x_where_id=v_limit_":
+                completer = TermCompleter(['1'])
+            elif state == "select_a_from_x_group_":
+                completer = TermCompleter(['by'])
+            elif state == "select_a_from_x_group_by_":
+                completer = TermCompleter(['id'])
+            elif state == "select_a_from_x_group_by_a,":
+                completer = TermCompleter(['id'])
+            elif state == "select_a_from_x_group_by_a_":
+                completer = TermCompleter(['limit'])
+            elif state == "select_a_from_x_group_by_a_limit_":
+                completer = TermCompleter(['1'])
 
-                new_document = Document(
-                    remaining_text,
-                    cursor_position=document.cursor_position - move_cursor,
-                )
+            elif state == "insert_":
+                completer = TermCompleter(['into'])
+            elif state == "insert_into_":
+                completer = TermCompleter(self.tables())
+            elif state == "insert_into_x_":
+                completer = TermCompleter(['values'])
+            elif state == "insert_into_x(":
+                completer = TermCompleter(['id'])
+            elif state == "insert_into_x(a,":
+                completer = TermCompleter(['id'])
+            elif state == "insert_into_x(a)_":
+                completer = TermCompleter(['values('])
+            elif state == "insert_into_x_values":
+                completer = TermCompleter(['('])
+            elif state == "insert_into_x_values(":
+                completer = TermCompleter(["'"])
 
-                for c in completer.get_completions(new_document, complete_event):
-                    yield c
-        else:
-            completer = WordCompleter(
-                list(self.options.keys()), ignore_case=self.ignore_case
-            )
+            elif state == "update_":
+                completer = TermCompleter(self.tables())
+            elif state == "update_x_":
+                completer = TermCompleter(['set'])
+            elif state in ["update_x_set_", "update_x_set_a=v,"]:
+                completer = TermCompleter(['id'])
+            elif state == "update_x_set_a":
+                completer = TermCompleter(['='])
+            elif state == "update_x_set_a=":
+                completer = TermCompleter(["'"])
+            elif state == "update_x_set_a=v_":
+                completer = TermCompleter(['where'])
+            elif state == "update_x_set_a=v_where_":
+                completer = TermCompleter(['id'])
+            elif state == "update_x_set_a=v_where_id":
+                completer = TermCompleter(['='])
+            elif state == "update_x_set_a=v_where_id=v_":
+                completer = TermCompleter(['and', 'or'])
+
+            elif state == "delete_":
+                completer = TermCompleter(['from'])
+            elif state == "delete_from_":
+                completer = TermCompleter(self.tables())
+            elif state == "delete_from_x_":
+                completer = TermCompleter(['where'])
+            elif state == "delete_from_x_where_":
+                completer = TermCompleter(['id'])
+            elif state == "delete_from_x_where_id":
+                completer = TermCompleter(['='])
+            elif state == "delete_from_x_where_id=":
+                completer = TermCompleter(["'"])
+            elif state == "delete_from_x_where_id=v_":
+                completer = TermCompleter(['and', 'or'])
+
+        if completer:
             for c in completer.get_completions(document, complete_event):
                 yield c
 
-    def completions(table: TableNameCompleter):
+    def traverse_tokens(self, text: str, tokens: list[Token], state: str = None, indent=0):
+        # state: str = None
+        for token in tokens:
+            if self.debug:
+                if token.ttype == T.Whitespace:
+                    print('_ ', end='')
+                elif token.ttype in [T.DML, T.Wildcard, T.Punctuation]:
+                    print(f'{token.value} ', end='')
+                elif token.ttype:
+                    tks = str(token.ttype).split('.')
+                    typ = tks[len(tks) - 1]
+                    if ' ' in token.value:
+                        print(f'"{token.value}:{typ}" ', end='')
+                    else:
+                        print(f'{token.value}:{typ} ', end='')
+                # print("  " * indent + f"Token: {token.value}, Type: {token.ttype}@{token.ttype.__class__}")
+            node: str = None
+            if token.is_group:
+                state = self.traverse_tokens(text, token.tokens, state, indent + 1)
+            else:
+                if not state:
+                    if token.ttype == T.Keyword.DML and token.value.lower() == 'select':
+                        state = 'select'
+                    if token.ttype == T.Keyword.DML and token.value.lower() == 'insert':
+                        state = 'insert'
+                    if token.ttype == T.Keyword.DML and token.value.lower() == 'update':
+                        state = 'update'
+                    if token.ttype == T.Keyword.DML and token.value.lower() == 'delete':
+                        state = 'delete'
+                    elif token.ttype == T.Name:
+                        state = 'dml_incomplete'
+
+                elif state == 'select':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_'
+                elif state == 'select_':
+                    if token.ttype == T.Name or token.ttype == T.Wildcard:
+                        state = 'select_a'
+                elif state == 'select_a':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_'
+                    elif token.ttype == T.Punctuation and token.value == ',':
+                        state = 'select_a,'
+                elif state == 'select_a,':
+                    if token.ttype == T.Name or token.ttype == T.Wildcard:
+                        state = 'select_a'
+                elif state == 'select_a_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'from':
+                        state = 'select_a_from'
+                elif state == 'select_a_from':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_'
+                elif state == 'select_a_from_':
+                    if token.ttype == T.Name:
+                        state = 'select_a_from_x'
+                elif state == 'select_a_from_x':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_x_'
+                    elif token.ttype == T.Punctuation and token.value == ',':
+                        state = 'select_a_from_x,'
+                elif state == 'select_a_from_x,':
+                    if token.ttype == T.Name:
+                        state = 'select_a_from_x'
+                elif state == 'select_a_from_x_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'where':
+                        state = 'select_a_from_x_where'
+                    elif token.ttype == T.Keyword and token.value.lower() == 'limit':
+                        state = 'select_a_from_x_where_id=v_limit'
+                    elif token.ttype == T.Keyword and token.value.lower() == 'group':
+                        state = 'select_a_from_x_group'
+                    elif token.ttype == T.Keyword and token.value.lower() == 'group by':
+                        state = 'select_a_from_x_group_by'
+                elif state == 'select_a_from_x_where':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_x_where_'
+                elif state == 'select_a_from_x_where_':
+                    if token.ttype == T.Name:
+                        state = 'select_a_from_x_where_id'
+                elif state == 'select_a_from_x_where_id':
+                    if token.ttype == T.Operator.Comparison:
+                        state = 'select_a_from_x_where_id='
+                elif state == 'select_a_from_x_where_id=':
+                    if token.ttype in [T.Literal.String.Single, T.Name]:
+                        state = 'select_a_from_x_where_id=v'
+                elif state == 'select_a_from_x_where_id=v':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_x_where_id=v_'
+                elif state == 'select_a_from_x_where_id=v_':
+                    if token.ttype == T.Keyword and token.value.lower() in ['and', 'or']:
+                        state = 'select_a_from_x_where'
+                    elif token.ttype == T.Keyword and token.value.lower() == 'group':
+                        state = 'select_a_from_x_group'
+                    elif token.ttype == T.Keyword and token.value.lower() == 'limit':
+                        state = 'select_a_from_x_where_id=v_limit'
+                elif state == 'select_a_from_x_group':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_x_group_'
+                elif state == 'select_a_from_x_group_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'by':
+                        state = 'select_a_from_x_group_by'
+                elif state == 'select_a_from_x_group_by':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_x_group_by_'
+                elif state == 'select_a_from_x_group_by_':
+                    if token.ttype == T.Name:
+                        state = 'select_a_from_x_group_by_a'
+                elif state == 'select_a_from_x_group_by_a':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_x_group_by_a_'
+                    elif token.ttype == T.Punctuation and token.value == ',':
+                        state = 'select_a_from_x_group_by_a,'
+                elif state == 'select_a_from_x_group_by_a,':
+                    if token.ttype == T.Name:
+                        state = 'select_a_from_x_group_by_a'
+                elif state == 'select_a_from_x_group_by_a_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'limit':
+                        state = 'select_a_from_x_where_id=v_limit'
+                elif state == 'select_a_from_x_where_id=v_limit':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'select_a_from_x_where_id=v_limit_'
+
+                elif state == 'insert':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'insert_'
+                elif state == 'insert_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'into':
+                        state = 'insert_into'
+                elif state == 'insert_into':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'insert_into_'
+                elif state == 'insert_into_':
+                    if token.ttype == T.Name:
+                        state = 'insert_into_x'
+                elif state == 'insert_into_x':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'insert_into_x_'
+                    elif token.ttype == T.Punctuation and token.value == '(':
+                        state = 'insert_into_x('
+                elif state == 'insert_into_x_':
+                    if token.ttype == T.Punctuation and token.value == '(':
+                        state = 'insert_into_x('
+                    elif token.ttype == T.Keyword and token.value.lower() == 'values':
+                        state = 'insert_into_x_values'
+                elif state == 'insert_into_x(':
+                    if token.ttype == T.Name:
+                        state = 'insert_into_x(a'
+                elif state == 'insert_into_x(a':
+                    if token.ttype == T.Punctuation and token.value == ',':
+                        state = 'insert_into_x(a,'
+                    elif token.ttype == T.Punctuation and token.value == ')':
+                        state = 'insert_into_x(a)'
+                elif state == 'insert_into_x(a,':
+                    if token.ttype == T.Name:
+                        state = 'insert_into_x(a'
+                elif state == 'insert_into_x(a)':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'insert_into_x(a)_'
+                elif state == 'insert_into_x(a)_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'values':
+                        state = 'insert_into_x_values'
+                elif state == 'insert_into_x_values':
+                    if token.ttype == T.Punctuation and token.value == '(':
+                        state = 'insert_into_x_values('
+                elif state == 'insert_into_x_values(':
+                    if token.ttype in [T.Literal.String.Single, T.Name]:
+                        state = 'insert_into_x_values(v'
+                elif state == 'insert_into_x_values(v':
+                    if token.ttype == T.Punctuation and token.value == ',':
+                        state = 'insert_into_x_values(v,'
+                    elif token.ttype == T.Punctuation and token.value == ')':
+                        state = 'insert_into_x_values(v)'
+                elif state == 'insert_into_x_values(v,':
+                    if token.ttype in [T.Literal.String.Single, T.Name]:
+                        state = 'insert_into_x_values(v'
+
+                elif state == 'update':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'update_'
+                elif state == 'update_':
+                    if token.ttype == T.Name:
+                        state = 'update_x'
+                elif state == 'update_x':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'update_x_'
+                elif state == 'update_x_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'set':
+                        state = 'update_x_set'
+                elif state == 'update_x_set':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'update_x_set_'
+                elif state == 'update_x_set_':
+                    if token.ttype == T.Name:
+                        state = 'update_x_set_a'
+                elif state == 'update_x_set_a':
+                    if token.ttype == T.Operator.Comparison:
+                        state = 'update_x_set_a='
+                elif state == 'update_x_set_a=':
+                    if token.ttype in [T.Literal.String.Single, T.Name]:
+                        state = 'update_x_set_a=v'
+                elif state == 'update_x_set_a=v':
+                    if token.ttype == T.Punctuation and token.value == ',':
+                        state = 'update_x_set_a=v,'
+                    elif token.ttype == T.Text.Whitespace:
+                        state = 'update_x_set_a=v_'
+                elif state == 'update_x_set_a=v,':
+                    if token.ttype == T.Name:
+                        state = 'update_x_set_a'
+                elif state == 'update_x_set_a=v_':
+                    if token.ttype == T.Punctuation and token.value == ',':
+                        state = 'update_x_set_a=v,'
+                    elif token.ttype == T.Keyword and token.value.lower() == 'where':
+                        state = 'update_x_set_a=v_where'
+                elif state == 'update_x_set_a=v_where':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'update_x_set_a=v_where_'
+                elif state == 'update_x_set_a=v_where_':
+                    if token.ttype == T.Name:
+                        state = 'update_x_set_a=v_where_id'
+                elif state == 'update_x_set_a=v_where_id':
+                    if token.ttype == T.Operator.Comparison:
+                        state = 'update_x_set_a=v_where_id='
+                elif state == 'update_x_set_a=v_where_id=':
+                    if token.ttype in [T.Literal.String.Single, T.Name]:
+                        state = 'update_x_set_a=v_where_id=v'
+                elif state == 'update_x_set_a=v_where_id=v':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'update_x_set_a=v_where_id=v_'
+                elif state == 'update_x_set_a=v_where_id=v_':
+                    if token.ttype == T.Keyword and token.value.lower() in ['and', 'or']:
+                        state = 'update_x_set_a=v_where'
+
+                elif state == 'delete':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'delete_'
+                elif state == 'delete_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'from':
+                        state = 'delete_from'
+                elif state == 'delete_from':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'delete_from_'
+                elif state == 'delete_from_':
+                    if token.ttype == T.Name:
+                        state = 'delete_from_x'
+                elif state == 'delete_from_x':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'delete_from_x_'
+                elif state == 'delete_from_x_':
+                    if token.ttype == T.Keyword and token.value.lower() == 'where':
+                        state = 'delete_from_x_where'
+                elif state == 'delete_from_x_where':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'delete_from_x_where_'
+                elif state == 'delete_from_x_where_':
+                    if token.ttype == T.Name:
+                        state = 'delete_from_x_where_id'
+                elif state == 'delete_from_x_where_id':
+                    if token.ttype == T.Operator.Comparison:
+                        state = 'delete_from_x_where_id='
+                elif state == 'delete_from_x_where_id=':
+                    if token.ttype in [T.Literal.String.Single, T.Name]:
+                        state = 'delete_from_x_where_id=v'
+                elif state == 'delete_from_x_where_id=v':
+                    if token.ttype == T.Text.Whitespace:
+                        state = 'delete_from_x_where_id=v_'
+                elif state == 'delete_from_x_where_id=v_':
+                    if token.ttype == T.Keyword and token.value.lower() in ['and', 'or']:
+                        state = 'delete_from_x_where'
+
+        return state
+
+    def completions(table_names: Callable[[], list[str]]):
         return {
-            'delete': {'from': table.nested({'where': any('id').nested({'=': any("'id'")})})},
-            'insert': {'into': table.nested({'values(': None})},
-            'select': any('*').nested({'from': table.nested({
-                'limit': any('1'),
-                'where': any('id').nested({'=': any("'id'").nested({'limit': any('1')})})
-            })}),
-            'update': table.nested({'set': {'column': {'=': None}}}),
+            'delete': SqlCompleter(table_names, 'delete'),
+            'insert': SqlCompleter(table_names, 'insert'),
+            'select': SqlCompleter(table_names, 'select'),
+            'update': SqlCompleter(table_names, 'update'),
         }

adam/sql/term_completer.py

@@ -0,0 +1,66 @@
+from typing import Callable, Iterable, List, Mapping, Optional, Pattern, Union
+
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion, WordCompleter
+from prompt_toolkit.document import Document
+from prompt_toolkit.formatted_text import AnyFormattedText
+
+__all__ = [
+    "TermCompleter",
+]
+
+class TermCompleter(WordCompleter):
+    def __init__(
+        self,
+        words: Union[List[str], Callable[[], List[str]]],
+        ignore_case: bool = False,
+        display_dict: Optional[Mapping[str, AnyFormattedText]] = None,
+        meta_dict: Optional[Mapping[str, AnyFormattedText]] = None,
+        WORD: bool = False,
+        sentence: bool = False,
+        match_middle: bool = False,
+        pattern: Optional[Pattern[str]] = None,
+    ) -> None:
+        super().__init__(words, ignore_case, display_dict, meta_dict, WORD, sentence, match_middle, pattern)
+
+    def get_completions(
+        self, document: Document, complete_event: CompleteEvent
+    ) -> Iterable[Completion]:
+        # Get list of words.
+        words = self.words
+        if callable(words):
+            words = words()
+
+        # Get word/text before cursor.
+        if self.sentence:
+            word_before_cursor = document.text_before_cursor
+        else:
+            word_before_cursor = document.get_word_before_cursor(
+                WORD=self.WORD, pattern=self.pattern
+            )
+
+        if self.ignore_case:
+            word_before_cursor = word_before_cursor.lower()
+
+        def word_matches(word: str) -> bool:
+            """True when the word before the cursor matches."""
+            if self.ignore_case:
+                word = word.lower()
+
+            if word_before_cursor in ['(', ',', '=']:
+                return True
+
+            if self.match_middle:
+                return word_before_cursor in word
+            else:
+                return word.startswith(word_before_cursor)
+
+        for a in words:
+            if word_matches(a):
+                display = self.display_dict.get(a, a)
+                display_meta = self.meta_dict.get(a, "")
+                yield Completion(
+                    a,
+                    -len(word_before_cursor),
+                    display=display,
+                    display_meta=display_meta,
+                )

adam/version.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-__version__ = "2.0.50"  #: the working version
+__version__ = "2.0.51"  #: the working version
 __release__ = "1.0.0"  #: the release version

{kaqing-2.0.50.dist-info → kaqing-2.0.51.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kaqing
-Version: 2.0.50
+Version: 2.0.51
 Summary: UNKNOWN
 Home-page: UNKNOWN
 License: UNKNOWN

{kaqing-2.0.50.dist-info → kaqing-2.0.51.dist-info}/RECORD

@@ -9,12 +9,12 @@ adam/embedded_apps.py,sha256=lKPx63mKzJbNmwz0rgL4gF76M9fDGxraYTtNAIGnZ_s,419
 adam/embedded_params.py,sha256=_9tBKpkSzBfzm-s3tUgZs8DcSVBnPA1iumG0ZRCbZIs,4586
 adam/log.py,sha256=gg5DK52wLPc9cjykeh0WFHyAk1qI3HEpGaAK8W2dzXY,1146
 adam/pod_exec_result.py,sha256=nq0xnCNOpUGBSijGF0H-YNrwBc9vUQs4DkvLMIFS5LQ,951
-adam/repl.py,sha256=ACIBgqitFt5z6lKFSeF4JOXbnCa3seZHWxFiMJ5Q9zw,7373
+adam/repl.py,sha256=X9ga1iZFIXADQxBXvztFyVNBrfBRxiFLxTUYkm11img,7328
 adam/repl_commands.py,sha256=WA90Rl27Juctzr3U3kfCDk5N-oYMKlfWbZeafUgk7k0,4723
 adam/repl_session.py,sha256=uIogcvWBh7wd8QQ-p_JgLsyJ8YJgINw5vOd6JIsd7Vo,472
 adam/repl_state.py,sha256=591d7gV6uQSFtm7IWdlIYAHjfAzs9bdvIkwlIAeKddE,7540
 adam/utils.py,sha256=2DoWsrcaioFFH0-RjT30qelVRPUJqCGTfz_ucfE7F8g,7406
-adam/version.py,sha256=LFuTm_lavjxHMfAJnqFwLX9zL3RVjQ6n-Au9M0IztXo,139
+adam/version.py,sha256=DIVzASNDynfH_uX-JULcKL8jQRSiIpR4Iw9R6p2ZFXM,139
 adam/checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 adam/checks/check.py,sha256=Qopr3huYcMu2bzQgb99dEUYjFzkjKHRI76S6KA9b9Rk,702
 adam/checks/check_context.py,sha256=FEHkQ32jY1EDopQ2uYWqy9v7aEEX1orLpJWhopwAlh4,402
@@ -69,7 +69,7 @@ adam/commands/nodetool.py,sha256=HV9yDzMhRjS4lw6UfV7Hc1pcmeSx5a1jU6cAEKSZ1Bg,233
 adam/commands/nodetool_commands.py,sha256=5IgWC3rmeDD1cgwqQjiiWzi-wJpJ3n_8pAzz_9phXuk,2635
 adam/commands/param_get.py,sha256=kPAAppK2T0tEFRnSIVFLDPIIGHhgLA7drJhn8TRyvvE,1305
 adam/commands/param_set.py,sha256=QDIuqfU80aWCB16OK49yf7XRaRTWwiLkwMsJuVikq9I,1271
-adam/commands/preview_table.py,sha256=EJZms-8sXqwDDNjix92z2tpU9823-WKv6y-Z3A7ucao,3068
+adam/commands/preview_table.py,sha256=5im47Uk6RclgkZD-Ci0lBs1eosnfvBtKt2lgsb_bohs,3068
 adam/commands/pwd.py,sha256=VlgFjxFl66I7Df1YI6cuiEeY6Q13lEavMKfrzHLESKo,2340
 adam/commands/report.py,sha256=Ky45LIzSlB_X4V12JZWjU3SA2u4_FKRencRTq7psOWU,1944
 adam/commands/restart.py,sha256=Hik1t5rjH2ATZv4tzwrGB3e44b3dNuATgY327_Nb8Bs,2044
@@ -77,8 +77,8 @@ adam/commands/rollout.py,sha256=52_4ijna3v-8Oug12et43DRHFDNhiN34p6xLTQmhdbQ,2959
 adam/commands/shell.py,sha256=wY_PIx7Lt6vuxhFArlfxdEnBbrouCJ3yNHhFn17DEqw,848
 adam/commands/watch.py,sha256=mmBFpB8T1V7zrNs5b2YNyDDztMym_ILPDdkrbdAXTas,2438
 adam/commands/cql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-adam/commands/cql/cql_completions.py,sha256=BfaBlLMBdSSbuYmuyVMhOcJ7IgELvYKJroq4qOjoZWc,529
-adam/commands/cql/cql_table_completer.py,sha256=ktTXC_Ii8NhxRbvUebc_Rg__Z7v2faQJBt3mR-5LPoI,633
+adam/commands/cql/cql_completions.py,sha256=dXe51NTWEJis76587IWSn9Av-cjC0J6KMaxlBKfF4wM,411
+adam/commands/cql/cql_table_completer.py,sha256=Tth6lmZ1eCEbJeAVZojTx594ttQeeVf-OjhhkSLyRnI,312
 adam/commands/cql/cql_utils.py,sha256=q5hzAUVh7h8iVVH2s0M4E76zWqaMUDXULMn412mfHII,3893
 adam/commands/cql/cqlsh.py,sha256=qEQufaDVi9FXkvruum6OHQDfLX01DVWVDnWsAjyCZYQ,2661
 adam/commands/deploy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -112,8 +112,8 @@ adam/commands/postgres/postgres_ls.py,sha256=HwZTgwGKXUqHX33S8aQPF6FqCrLqtoz4cLy
 adam/commands/postgres/postgres_preview.py,sha256=MLzdEc4mvNj6V1Q8jO5OPznXyYELJHgd35_eQgLlNIU,1274
 adam/commands/postgres/postgres_session.py,sha256=RcqkCgtA78M-9LKTwG6pp8n9JwjmURXgf1FknIIPl9g,9305
 adam/commands/postgres/postgres_utils.py,sha256=mC5PZXrfxzqZt6n_HYASwe6Y-OyAK3QwEtDeVb_TKrA,877
-adam/commands/postgres/psql_completions.py,sha256=huEvqYTjBk_3CY_Tu1dDeUlaNwPIMLagnv9QuSWCB5U,392
-adam/commands/postgres/psql_table_completer.py,sha256=8-4flf-PEtQGOSjTdA_93ht1EoZGZ4-dAbrXtyVblS4,819
+adam/commands/postgres/psql_completions.py,sha256=IHcSy-fh028_rYw2gcXaPuf_4TidP5a2hPrl63N643M,322
+adam/commands/postgres/psql_table_completer.py,sha256=WI9VvnI2w6U8HZOdPPiacpf4ShPjHuunHnOtrx7LYG8,509
 adam/commands/reaper/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 adam/commands/reaper/reaper.py,sha256=83R0ZRitEwaYKKssfKxn3zAzLnWIP9QKd1mA6awceS8,1908
 adam/commands/reaper/reaper_forward.py,sha256=mUp409MzT91cVXGxoPfBGceaR3qZ0rVdWKGdyzPNzSA,3177
@@ -164,10 +164,9 @@ adam/k8s_utils/services.py,sha256=EOJJGACVbbRvu5T3rMKqIJqgYic1_MSJ17EA0TJ6UOk,31
 adam/k8s_utils/statefulsets.py,sha256=hiBOmJZ3KTI6_naAFzNoW1NoYnnBG35BZ7RMdPhNC6o,4664
 adam/k8s_utils/volumes.py,sha256=RIBmlOSWM3V3QVXLCFT0owVOyh4rGG1ETp521a-6ndo,1137
 adam/sql/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-adam/sql/any_completer.py,sha256=hPnhqAyWIk1-gyZsna1X7AJ8po23cYR-MvYY-7iBn3w,3184
-adam/sql/sql_completer.py,sha256=9JSZj-Rv5aag720xuQLgq9WlseLtPEAcQXx6OH-pFP8,2160
+adam/sql/sql_completer.py,sha256=RhfE8_ecn84HtiCFPMDvKrkPySFXVIJ2ez9bN8-wdP4,20902
 adam/sql/sql_utils.py,sha256=MLoxB9h22WZiANu0SZzmBJcY2gtb6f_D4jnoJEjLgPc,171
-adam/sql/table_name_completer.py,sha256=n_vJbsfM4XYN0tCjov1l-4skFYO3xaLcyOVcZ77mteo,519
+adam/sql/term_completer.py,sha256=O-sUxFVc1DJmPQCdT-XPK2SSkUe4AL1dw8ZPXXicATY,2273
 adam/sso/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 adam/sso/authenticator.py,sha256=BCm16L9zf5aLU47-sTCnudn2zLPwd8M2wwRminJfsqw,615
 adam/sso/authn_ad.py,sha256=fDW8UR3WWykny5Awa5dQjjBUSFzIDz4aMn-lwXoABl8,5857
@@ -178,8 +177,8 @@ adam/sso/idp.py,sha256=fvcwUw_URTgsO6ySaqTIw0zQT2qRO1IPSGhf6rPtybo,5804
 adam/sso/idp_login.py,sha256=QAtCUeDTVWliJy40RK_oac8Vgybr13xH8wzeBoxPaa8,1754
 adam/sso/idp_session.py,sha256=9BUHNRf70u4rVKrVY1HKPOEmOviXvkjam8WJxmXSKIM,1735
 adam/sso/sso_config.py,sha256=5N8WZgIJQBtHUy585XLRWKjpU87_v6QluyNK9E27D5s,2459
-kaqing-2.0.50.dist-info/METADATA,sha256=6cRmIvrJppOAGCWN23OkycCXqvwVuUh8CMOcImdjjxs,132
-kaqing-2.0.50.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-kaqing-2.0.50.dist-info/entry_points.txt,sha256=SkzhuQJUWsXOzHeZ5TgQ2c3_g53UGK23zzJU_JTZOZI,39
-kaqing-2.0.50.dist-info/top_level.txt,sha256=8_2PZkwBb-xDcnc8a2rAbQeJhXKXskc7zTP7pSPa1fw,5
-kaqing-2.0.50.dist-info/RECORD,,
+kaqing-2.0.51.dist-info/METADATA,sha256=yrXdUA18-Fl_t3WHsjhq9WePo338WX7YSh0VD0M6fgM,132
+kaqing-2.0.51.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+kaqing-2.0.51.dist-info/entry_points.txt,sha256=SkzhuQJUWsXOzHeZ5TgQ2c3_g53UGK23zzJU_JTZOZI,39
+kaqing-2.0.51.dist-info/top_level.txt,sha256=8_2PZkwBb-xDcnc8a2rAbQeJhXKXskc7zTP7pSPa1fw,5
+kaqing-2.0.51.dist-info/RECORD,,

adam/sql/any_completer.py

@@ -1,84 +0,0 @@
-from typing import Any, Dict, Iterable, Mapping, Optional, Set, Union
-from prompt_toolkit.completion import CompleteEvent, Completer, Completion, NestedCompleter, WordCompleter
-from prompt_toolkit.document import Document
-
-from adam.sql.sql_utils import safe_terms
-
-NestedDict = Mapping[str, Union[Any, Set[str], None, Completer]]
-
-class AnyCompleter(Completer):
-    def __init__(self, default: str = None, nested_dict: NestedDict = {}, ignore_case: bool = True):
-        self.default = default
-        self.ignore_case = ignore_case
-        self.append_nested_dict(nested_dict)
-
-    def append_nested_dict(self, data: NestedDict) -> "AnyCompleter":
-        options: Dict[str, Optional[Completer]] = {}
-        for key, value in data.items():
-            if isinstance(value, Completer):
-                options[key] = value
-            elif isinstance(value, dict):
-                options[key] = NestedCompleter.from_nested_dict(value)
-            elif isinstance(value, set):
-                options[key] = NestedCompleter.from_nested_dict({item: None for item in value})
-            else:
-                assert value is None
-                options[key] = None
-
-        self.options = options
-
-        return self
-
-    def get_completions(
-        self, document: Document, complete_event: CompleteEvent
-    ) -> Iterable[Completion]:
-        text = document.text_before_cursor.lstrip()
-        stripped_len = len(document.text_before_cursor) - len(text)
-
-        terms, has_space = safe_terms(text)
-        if has_space:
-            second_term = None
-            if len(terms) > 1:
-                second_term = terms[1]
-
-            yielded = False
-            if second_term:
-                completer = self.options.get(second_term)
-
-                if completer is not None:
-                    first_term = terms[0]
-                    remaining_text = text[len(first_term) :].lstrip()
-                    move_cursor = len(text) - len(remaining_text) + stripped_len
-
-                    remaining_text = remaining_text[len(second_term) :].lstrip()
-                    move_cursor = len(text) - len(remaining_text) + stripped_len
-
-                    new_document = Document(
-                        remaining_text,
-                        cursor_position=document.cursor_position - move_cursor,
-                    )
-
-                    for c in completer.get_completions(new_document, complete_event):
-                        yield c
-                    yielded = True
-
-            if not yielded:
-                completer = WordCompleter(
-                    list(self.options.keys()), ignore_case=self.ignore_case
-                )
-                for c in completer.get_completions(document, complete_event):
-                    yield c
-        elif words := self.words():
-            for c in words.get_completions(document, complete_event):
-                yield c
-
-    def words(self):
-        if not self.default:
-            return None
-
-        return WordCompleter(
-            [self.default], ignore_case=self.ignore_case
-        )
-
-    def nested(self, data: NestedDict) -> 'AnyCompleter':
-        return AnyCompleter(self.default).append_nested_dict(data)

adam/sql/table_name_completer.py

@@ -1,17 +0,0 @@
-from abc import abstractmethod
-from prompt_toolkit.completion import  WordCompleter
-
-from .any_completer import AnyCompleter, NestedDict
-
-class TableNameCompleter(AnyCompleter):
-    def __init__(self, nested_dict: NestedDict = {}, ignore_case: bool = True):
-        super().__init__(nested_dict=nested_dict, ignore_case=ignore_case)
-
-    def words(self):
-        return WordCompleter(
-            self.tables(), ignore_case=self.ignore_case
-        )
-
-    @abstractmethod
-    def tables(self) -> list[str]:
-        pass