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_create_table_parser(add_help: bool = True) -> argshell.ArgShellParser:
 40    """Returns a parser for adding a table to the database."""
 41    parser = argshell.ArgShellParser(add_help=add_help)
 42    parser.add_argument(
 43        "table_name", type=str, help=""" The name of the table to add. """
 44    )
 45    parser.add_argument(
 46        "-c",
 47        "--columns",
 48        type=str,
 49        nargs="*",
 50        default=[],
 51        help=""" A list of column definitions for the table.
 52        i.e. 'mytable -c "username text unique" "date_registered timestamp" "email_verified int default 0"'""",
 53    )
 54    return parser
 55
 56
 57def get_add_row_parser() -> argshell.ArgShellParser:
 58    """Returns a parser for adding a row to a table."""
 59    parser = argshell.ArgShellParser(parents=[get_create_table_parser(False)])
 60    parser.add_argument(
 61        "-v",
 62        "--values",
 63        nargs="*",
 64        default=[],
 65        help=""" If -c/--columns is supplied, it and this flag must have the same number of elements.
 66        If -c/--columns is not supplied, an element must be supplied to this flag for every column in the table. """,
 67    )
 68    return parser
 69
 70
 71def get_search_parser() -> argshell.ArgShellParser:
 72    """Returns a search parser."""
 73    parser = argshell.ArgShellParser()
 74    parser.add_argument(
 75        "search_string", type=str, help=""" Search all columns for this substring. """
 76    )
 77    parser.add_argument(
 78        "-t",
 79        "--tables",
 80        type=str,
 81        nargs="*",
 82        default=None,
 83        help="""Limits search to a specific list of tables""",
 84    )
 85    parser.add_argument(
 86        "-c",
 87        "--columns",
 88        type=str,
 89        nargs="*",
 90        default=None,
 91        help=""" Limits search to these columns. """,
 92    )
 93    return parser
 94
 95
 96def get_lookup_parser() -> argshell.ArgShellParser:
 97    """Returns a parser for row lookup functions."""
 98    parser = argshell.ArgShellParser(parents=[_get_base_parser()])
 99    parser.add_argument(
100        "-c",
101        "--columns",
102        type=str,
103        nargs="*",
104        default=[],
105        help=""" Limits what columns are returned.""",
106    )
107    parser.add_argument(
108        "-o",
109        "--order_by",
110        type=str,
111        default=None,
112        help=""" The name of a column to sort results by.
113        Can include 'desc' as part of the argument.""",
114    )
115    parser.add_argument(
116        "-l",
117        "--limit",
118        type=int,
119        default=None,
120        help=""" Only return this many results. """,
121    )
122    return parser
123
124
125def get_update_parser() -> argshell.ArgShellParser:
126    """Returns a parser for update function."""
127    parser = argshell.ArgShellParser(parents=[_get_base_parser()])
128    parser.add_argument(
129        "-c", "--column", required=True, type=str, help=""" The column to update. """
130    )
131    parser.add_argument(
132        "-v",
133        "--new_value",
134        required=True,
135        help=""" The new value to update with. """,
136    )
137    return parser
138
139
140def get_add_column_parser() -> argshell.ArgShellParser:
141    """Returns a parser for the add column function."""
142    parser = argshell.ArgShellParser()
143    parser.add_argument(
144        "column_name", type=str, help=""" The name of the column to add. """
145    )
146    parser.add_argument(
147        "type", type=str, help=""" The data type of the column to add. """
148    )
149    parser.add_argument(
150        "-t",
151        "--tables",
152        type=str,
153        nargs="*",
154        default=[],
155        help="""Table(s) to add the column to.
156        If not specified, the column will be added to every table in the database.""",
157    )
158    parser.add_argument(
159        "-d",
160        "--default_value",
161        default=None,
162        help=""" Default value for the new column. """,
163    )
164    return parser
165
166
167# ============================================================post parsers============================================================
168def convert_match_pairs(args: argshell.Namespace) -> argshell.Namespace:
169    """Create a list of tuples from match_pairs."""
170    if args.match_pairs:
171        args.match_pairs = [
172            (col, val)
173            for col, val in zip(args.match_pairs[::2], args.match_pairs[1::2])
174        ]
175    return args
176
177
178def verify_matching_length(args: argshell.Namespace) -> argshell.Namespace:
179    """Raise an error if -c/--columns is greater than zero and has
180    a different number of elements than -v/--values."""
181    if args.columns and len(args.columns) != len(args.values):
182        raise ValueError(
183            f"Column/Value length mismatch: {len(args.columns)} columns and {len(args.values)} values provided."
184        )
185    return args
def get_create_table_parser(add_help: bool = True) -> argshell.argshell.ArgShellParser:
40def get_create_table_parser(add_help: bool = True) -> argshell.ArgShellParser:
41    """Returns a parser for adding a table to the database."""
42    parser = argshell.ArgShellParser(add_help=add_help)
43    parser.add_argument(
44        "table_name", type=str, help=""" The name of the table to add. """
45    )
46    parser.add_argument(
47        "-c",
48        "--columns",
49        type=str,
50        nargs="*",
51        default=[],
52        help=""" A list of column definitions for the table.
53        i.e. 'mytable -c "username text unique" "date_registered timestamp" "email_verified int default 0"'""",
54    )
55    return parser

Returns a parser for adding a table to the database.

def get_add_row_parser() -> argshell.argshell.ArgShellParser:
58def get_add_row_parser() -> argshell.ArgShellParser:
59    """Returns a parser for adding a row to a table."""
60    parser = argshell.ArgShellParser(parents=[get_create_table_parser(False)])
61    parser.add_argument(
62        "-v",
63        "--values",
64        nargs="*",
65        default=[],
66        help=""" If -c/--columns is supplied, it and this flag must have the same number of elements.
67        If -c/--columns is not supplied, an element must be supplied to this flag for every column in the table. """,
68    )
69    return parser

Returns a parser for adding a row to a table.

def get_search_parser() -> argshell.argshell.ArgShellParser:
72def get_search_parser() -> argshell.ArgShellParser:
73    """Returns a search parser."""
74    parser = argshell.ArgShellParser()
75    parser.add_argument(
76        "search_string", type=str, help=""" Search all columns for this substring. """
77    )
78    parser.add_argument(
79        "-t",
80        "--tables",
81        type=str,
82        nargs="*",
83        default=None,
84        help="""Limits search to a specific list of tables""",
85    )
86    parser.add_argument(
87        "-c",
88        "--columns",
89        type=str,
90        nargs="*",
91        default=None,
92        help=""" Limits search to these columns. """,
93    )
94    return parser

Returns a search parser.

def get_lookup_parser() -> argshell.argshell.ArgShellParser:
 97def get_lookup_parser() -> argshell.ArgShellParser:
 98    """Returns a parser for row lookup functions."""
 99    parser = argshell.ArgShellParser(parents=[_get_base_parser()])
100    parser.add_argument(
101        "-c",
102        "--columns",
103        type=str,
104        nargs="*",
105        default=[],
106        help=""" Limits what columns are returned.""",
107    )
108    parser.add_argument(
109        "-o",
110        "--order_by",
111        type=str,
112        default=None,
113        help=""" The name of a column to sort results by.
114        Can include 'desc' as part of the argument.""",
115    )
116    parser.add_argument(
117        "-l",
118        "--limit",
119        type=int,
120        default=None,
121        help=""" Only return this many results. """,
122    )
123    return parser

Returns a parser for row lookup functions.

def get_update_parser() -> argshell.argshell.ArgShellParser:
126def get_update_parser() -> argshell.ArgShellParser:
127    """Returns a parser for update function."""
128    parser = argshell.ArgShellParser(parents=[_get_base_parser()])
129    parser.add_argument(
130        "-c", "--column", required=True, type=str, help=""" The column to update. """
131    )
132    parser.add_argument(
133        "-v",
134        "--new_value",
135        required=True,
136        help=""" The new value to update with. """,
137    )
138    return parser

Returns a parser for update function.

def get_add_column_parser() -> argshell.argshell.ArgShellParser:
141def get_add_column_parser() -> argshell.ArgShellParser:
142    """Returns a parser for the add column function."""
143    parser = argshell.ArgShellParser()
144    parser.add_argument(
145        "column_name", type=str, help=""" The name of the column to add. """
146    )
147    parser.add_argument(
148        "type", type=str, help=""" The data type of the column to add. """
149    )
150    parser.add_argument(
151        "-t",
152        "--tables",
153        type=str,
154        nargs="*",
155        default=[],
156        help="""Table(s) to add the column to.
157        If not specified, the column will be added to every table in the database.""",
158    )
159    parser.add_argument(
160        "-d",
161        "--default_value",
162        default=None,
163        help=""" Default value for the new column. """,
164    )
165    return parser

Returns a parser for the add column function.

def convert_match_pairs(args: argshell.argshell.Namespace) -> argshell.argshell.Namespace:
169def convert_match_pairs(args: argshell.Namespace) -> argshell.Namespace:
170    """Create a list of tuples from match_pairs."""
171    if args.match_pairs:
172        args.match_pairs = [
173            (col, val)
174            for col, val in zip(args.match_pairs[::2], args.match_pairs[1::2])
175        ]
176    return args

Create a list of tuples from match_pairs.

def verify_matching_length(args: argshell.argshell.Namespace) -> argshell.argshell.Namespace:
179def verify_matching_length(args: argshell.Namespace) -> argshell.Namespace:
180    """Raise an error if -c/--columns is greater than zero and has
181    a different number of elements than -v/--values."""
182    if args.columns and len(args.columns) != len(args.values):
183        raise ValueError(
184            f"Column/Value length mismatch: {len(args.columns)} columns and {len(args.values)} values provided."
185        )
186    return args

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