databased.dbparsers

  1import argshell
  2
  3""" Parser building functions for DBShell """
  4
  5
  6def _get_base_parser(add_help: bool = False) -> argshell.ArgShellParser:
  7    """Returns base parser containing -t/--tables and -m/--match_pairs switches."""
  8    parser = argshell.ArgShellParser(add_help=add_help)
  9    parser.add_argument(
 10        "-t",
 11        "--tables",
 12        type=str,
 13        nargs="*",
 14        default=[],
 15        help="""Limits command to a specific list of tables""",
 16    )
 17    parser.add_argument(
 18        "-m",
 19        "--match_pairs",
 20        type=str,
 21        nargs="*",
 22        default=[],
 23        help=""" Pairs of columns and values to use for narrowing the scope of row operations.
 24        i.e. 'find -t users -m name Bob state Alaska last_login *' will print
 25        all rows from the users table that have the name Bob,
 26        are from the state Alaska, and last logged in at any date.""",
 27    )
 28    parser.add_argument(
 29        "-p",
 30        "--partial_matching",
 31        action="store_true",
 32        help=""" When selecting rows using a string, the string can be a substring instead of an exact match.
 33        i.e. "-t names -m first theo" only returns rows from names where the first name is exactly 'theo'.
 34        "-t names -m first theo -p" would return rows with first names of 'theo', but also rows with names like 'theodore'.  """,
 35    )
 36    return parser
 37
 38
 39def get_info_parser() -> argshell.ArgShellParser:
 40    """Returns info parser."""
 41    parser = argshell.ArgShellParser()
 42    parser.add_argument(
 43        "-t",
 44        "--tables",
 45        type=str,
 46        nargs="*",
 47        default=[],
 48        help=""" Only display info for this table(s). """,
 49    )
 50    parser.add_argument(
 51        "-rc",
 52        "--rowcount",
 53        action="store_true",
 54        help=""" Count and display the number of rows for each table. """,
 55    )
 56    return parser
 57
 58
 59def get_create_table_parser(add_help: bool = True) -> argshell.ArgShellParser:
 60    """Returns a parser for adding a table to the database."""
 61    parser = argshell.ArgShellParser(add_help=add_help)
 62    parser.add_argument(
 63        "table_name", type=str, help=""" The name of the table to add. """
 64    )
 65    parser.add_argument(
 66        "-c",
 67        "--columns",
 68        type=str,
 69        nargs="*",
 70        default=[],
 71        help=""" A list of column definitions for the table.
 72        i.e. 'mytable -c "username text unique" "date_registered timestamp" "email_verified int default 0"'""",
 73    )
 74    return parser
 75
 76
 77def get_add_row_parser() -> argshell.ArgShellParser:
 78    """Returns a parser for adding a row to a table."""
 79    parser = argshell.ArgShellParser(parents=[get_create_table_parser(False)])
 80    parser.add_argument(
 81        "-v",
 82        "--values",
 83        nargs="*",
 84        default=[],
 85        help=""" If -c/--columns is supplied, it and this flag must have the same number of elements.
 86        If -c/--columns is not supplied, an element must be supplied to this flag for every column in the table. """,
 87    )
 88    return parser
 89
 90
 91def get_search_parser() -> argshell.ArgShellParser:
 92    """Returns a search parser."""
 93    parser = argshell.ArgShellParser()
 94    parser.add_argument(
 95        "search_string", type=str, help=""" Search all columns for this substring. """
 96    )
 97    parser.add_argument(
 98        "-t",
 99        "--tables",
100        type=str,
101        nargs="*",
102        default=None,
103        help="""Limits search to a specific list of tables""",
104    )
105    parser.add_argument(
106        "-c",
107        "--columns",
108        type=str,
109        nargs="*",
110        default=None,
111        help=""" Limits search to these columns. """,
112    )
113    return parser
114
115
116def get_lookup_parser() -> argshell.ArgShellParser:
117    """Returns a parser for row lookup functions."""
118    parser = argshell.ArgShellParser(parents=[_get_base_parser()])
119    parser.add_argument(
120        "-c",
121        "--columns",
122        type=str,
123        nargs="*",
124        default=[],
125        help=""" Limits what columns are returned.""",
126    )
127    parser.add_argument(
128        "-o",
129        "--order_by",
130        type=str,
131        default=None,
132        help=""" The name of a column to sort results by.
133        Can include 'desc' as part of the argument.""",
134    )
135    parser.add_argument(
136        "-l",
137        "--limit",
138        type=int,
139        default=None,
140        help=""" Only return this many results. """,
141    )
142    return parser
143
144
145def get_update_parser() -> argshell.ArgShellParser:
146    """Returns a parser for update function."""
147    parser = argshell.ArgShellParser(parents=[_get_base_parser()])
148    parser.add_argument(
149        "-c", "--column", required=True, type=str, help=""" The column to update. """
150    )
151    parser.add_argument(
152        "-v",
153        "--new_value",
154        required=True,
155        help=""" The new value to update with. """,
156    )
157    return parser
158
159
160def get_add_column_parser() -> argshell.ArgShellParser:
161    """Returns a parser for the add column function."""
162    parser = argshell.ArgShellParser()
163    parser.add_argument(
164        "column_name", type=str, help=""" The name of the column to add. """
165    )
166    parser.add_argument(
167        "type", type=str, help=""" The data type of the column to add. """
168    )
169    parser.add_argument(
170        "-t",
171        "--tables",
172        type=str,
173        nargs="*",
174        default=[],
175        help="""Table(s) to add the column to.
176        If not specified, the column will be added to every table in the database.""",
177    )
178    parser.add_argument(
179        "-d",
180        "--default_value",
181        default=None,
182        help=""" Default value for the new column. """,
183    )
184    return parser
185
186
187# ============================================================post parsers============================================================
188def convert_match_pairs(args: argshell.Namespace) -> argshell.Namespace:
189    """Create a list of tuples from match_pairs."""
190    if args.match_pairs:
191        args.match_pairs = [
192            (col, val)
193            for col, val in zip(args.match_pairs[::2], args.match_pairs[1::2])
194        ]
195    return args
196
197
198def verify_matching_length(args: argshell.Namespace) -> argshell.Namespace:
199    """Raise an error if -c/--columns is greater than zero and has
200    a different number of elements than -v/--values."""
201    if args.columns and len(args.columns) != len(args.values):
202        raise ValueError(
203            f"Column/Value length mismatch: {len(args.columns)} columns and {len(args.values)} values provided."
204        )
205    return args
def get_info_parser() -> argshell.argshell.ArgShellParser:
40def get_info_parser() -> argshell.ArgShellParser:
41    """Returns info parser."""
42    parser = argshell.ArgShellParser()
43    parser.add_argument(
44        "-t",
45        "--tables",
46        type=str,
47        nargs="*",
48        default=[],
49        help=""" Only display info for this table(s). """,
50    )
51    parser.add_argument(
52        "-rc",
53        "--rowcount",
54        action="store_true",
55        help=""" Count and display the number of rows for each table. """,
56    )
57    return parser

Returns info parser.

def get_create_table_parser(add_help: bool = True) -> argshell.argshell.ArgShellParser:
60def get_create_table_parser(add_help: bool = True) -> argshell.ArgShellParser:
61    """Returns a parser for adding a table to the database."""
62    parser = argshell.ArgShellParser(add_help=add_help)
63    parser.add_argument(
64        "table_name", type=str, help=""" The name of the table to add. """
65    )
66    parser.add_argument(
67        "-c",
68        "--columns",
69        type=str,
70        nargs="*",
71        default=[],
72        help=""" A list of column definitions for the table.
73        i.e. 'mytable -c "username text unique" "date_registered timestamp" "email_verified int default 0"'""",
74    )
75    return parser

Returns a parser for adding a table to the database.

def get_add_row_parser() -> argshell.argshell.ArgShellParser:
78def get_add_row_parser() -> argshell.ArgShellParser:
79    """Returns a parser for adding a row to a table."""
80    parser = argshell.ArgShellParser(parents=[get_create_table_parser(False)])
81    parser.add_argument(
82        "-v",
83        "--values",
84        nargs="*",
85        default=[],
86        help=""" If -c/--columns is supplied, it and this flag must have the same number of elements.
87        If -c/--columns is not supplied, an element must be supplied to this flag for every column in the table. """,
88    )
89    return parser

Returns a parser for adding a row to a table.

def get_search_parser() -> argshell.argshell.ArgShellParser:
 92def get_search_parser() -> argshell.ArgShellParser:
 93    """Returns a search parser."""
 94    parser = argshell.ArgShellParser()
 95    parser.add_argument(
 96        "search_string", type=str, help=""" Search all columns for this substring. """
 97    )
 98    parser.add_argument(
 99        "-t",
100        "--tables",
101        type=str,
102        nargs="*",
103        default=None,
104        help="""Limits search to a specific list of tables""",
105    )
106    parser.add_argument(
107        "-c",
108        "--columns",
109        type=str,
110        nargs="*",
111        default=None,
112        help=""" Limits search to these columns. """,
113    )
114    return parser

Returns a search parser.

def get_lookup_parser() -> argshell.argshell.ArgShellParser:
117def get_lookup_parser() -> argshell.ArgShellParser:
118    """Returns a parser for row lookup functions."""
119    parser = argshell.ArgShellParser(parents=[_get_base_parser()])
120    parser.add_argument(
121        "-c",
122        "--columns",
123        type=str,
124        nargs="*",
125        default=[],
126        help=""" Limits what columns are returned.""",
127    )
128    parser.add_argument(
129        "-o",
130        "--order_by",
131        type=str,
132        default=None,
133        help=""" The name of a column to sort results by.
134        Can include 'desc' as part of the argument.""",
135    )
136    parser.add_argument(
137        "-l",
138        "--limit",
139        type=int,
140        default=None,
141        help=""" Only return this many results. """,
142    )
143    return parser

Returns a parser for row lookup functions.

def get_update_parser() -> argshell.argshell.ArgShellParser:
146def get_update_parser() -> argshell.ArgShellParser:
147    """Returns a parser for update function."""
148    parser = argshell.ArgShellParser(parents=[_get_base_parser()])
149    parser.add_argument(
150        "-c", "--column", required=True, type=str, help=""" The column to update. """
151    )
152    parser.add_argument(
153        "-v",
154        "--new_value",
155        required=True,
156        help=""" The new value to update with. """,
157    )
158    return parser

Returns a parser for update function.

def get_add_column_parser() -> argshell.argshell.ArgShellParser:
161def get_add_column_parser() -> argshell.ArgShellParser:
162    """Returns a parser for the add column function."""
163    parser = argshell.ArgShellParser()
164    parser.add_argument(
165        "column_name", type=str, help=""" The name of the column to add. """
166    )
167    parser.add_argument(
168        "type", type=str, help=""" The data type of the column to add. """
169    )
170    parser.add_argument(
171        "-t",
172        "--tables",
173        type=str,
174        nargs="*",
175        default=[],
176        help="""Table(s) to add the column to.
177        If not specified, the column will be added to every table in the database.""",
178    )
179    parser.add_argument(
180        "-d",
181        "--default_value",
182        default=None,
183        help=""" Default value for the new column. """,
184    )
185    return parser

Returns a parser for the add column function.

def convert_match_pairs(args: argshell.argshell.Namespace) -> argshell.argshell.Namespace:
189def convert_match_pairs(args: argshell.Namespace) -> argshell.Namespace:
190    """Create a list of tuples from match_pairs."""
191    if args.match_pairs:
192        args.match_pairs = [
193            (col, val)
194            for col, val in zip(args.match_pairs[::2], args.match_pairs[1::2])
195        ]
196    return args

Create a list of tuples from match_pairs.

def verify_matching_length(args: argshell.argshell.Namespace) -> argshell.argshell.Namespace:
199def verify_matching_length(args: argshell.Namespace) -> argshell.Namespace:
200    """Raise an error if -c/--columns is greater than zero and has
201    a different number of elements than -v/--values."""
202    if args.columns and len(args.columns) != len(args.values):
203        raise ValueError(
204            f"Column/Value length mismatch: {len(args.columns)} columns and {len(args.values)} values provided."
205        )
206    return args

Raise an error if -c/--columns is greater than zero and has a different number of elements than -v/--values.