databased.dbparsers

  1import argshell
  2
  3""" Parser building functions for DBShell """
  4
  5
  6def add_where_argument(parser: argshell.ArgShellParser) -> argshell.ArgShellParser:
  7    """Add an optional `where` argument to the parser and return it.
  8
  9    The added argument has a default value of `None` and has `nargs="?"`"""
 10    parser.add_argument(
 11        "where",
 12        type=str,
 13        default=None,
 14        nargs="?",
 15        help=""" The `WHERE` clause to use, if any. Don't include "WHERE" keyword in argument string. """,
 16    )
 17    return parser
 18
 19
 20def get_backup_parser() -> argshell.ArgShellParser:
 21    """Returns a parser for the backup command."""
 22    parser = argshell.ArgShellParser()
 23    parser.add_argument(
 24        "-t",
 25        "--timestamp",
 26        action="store_true",
 27        help=""" Add a timestamp to the backup file name to prevent overwriting previous backups. """,
 28    )
 29    return parser
 30
 31
 32def get_select_parser() -> argshell.ArgShellParser:
 33    """Returns a parser for use with `select`."""
 34    parser = argshell.ArgShellParser()
 35    parser.add_argument("table", type=str, help=""" The table to select from. """)
 36    parser.add_argument(
 37        "-c",
 38        "--columns",
 39        type=str,
 40        default=["*"],
 41        nargs="*",
 42        help=""" The columns to select. If a column identifier has a space in it, like `COUNT(*) AS num_things`, enclose it in quotes. If no args given, `*` will be used. """,
 43    )
 44    parser.add_argument(
 45        "-j",
 46        "--joins",
 47        type=str,
 48        nargs="*",
 49        default=None,
 50        help=""" Joins to perform, if any. Should be in the form: `"{join type} JOIN {table2} ON {table}.{column} = {table2}.{column}"`. Enclose separate joins in quotes. """,
 51    )
 52    parser.add_argument(
 53        "-w",
 54        "--where",
 55        type=str,
 56        default=None,
 57        help=""" The `WHERE` clause to use, if any. Don't include "WHERE" keyword in argument string. """,
 58    )
 59    parser.add_argument(
 60        "-g",
 61        "--group_by",
 62        type=str,
 63        default=None,
 64        nargs="*",
 65        help=""" The `GROUP BY` clause to use, if any. Don't include the keyword. """,
 66    )
 67    parser.add_argument(
 68        "-H",
 69        "--Having",
 70        type=str,
 71        default=None,
 72        help=""" The `HAVING` clause to use, if any. Don't include keyword. """,
 73    )
 74    parser.add_argument(
 75        "-o",
 76        "--order_by",
 77        type=str,
 78        default=None,
 79        nargs="*",
 80        help=""" The `ORDER BY` clause to use, if any. Don't include keyword. """,
 81    )
 82    parser.add_argument(
 83        "-l",
 84        "--limit",
 85        type=str,
 86        default=None,
 87        help=""" The `LIMIT` clause to use, if any. Don't include keyword. """,
 88    )
 89    parser.add_argument(
 90        "-ec",
 91        "--exclude_columns",
 92        type=str,
 93        nargs="*",
 94        default=None,
 95        help=""" Return all columns except these columns.""",
 96    )
 97    return parser
 98
 99
100def get_count_parser() -> argshell.ArgShellParser:
101    """Returns a count parser."""
102    parser = argshell.ArgShellParser()
103    parser.add_argument("table", type=str, help=""" The table to count from. """)
104    parser = add_where_argument(parser)
105    parser.add_argument(
106        "-c",
107        "--column",
108        type=str,
109        default="*",
110        help=""" The column to count on. Default is `*`.""",
111    )
112    parser.add_argument(
113        "-d",
114        "--distinct",
115        action="store_true",
116        help=""" Whether the count should use `DISTINCT`.""",
117    )
118    return parser
119
120
121def get_drop_column_parser() -> argshell.ArgShellParser:
122    parser = argshell.ArgShellParser()
123    parser.add_argument(
124        "table", type=str, help=""" The table to drop the column from. """
125    )
126    parser.add_argument("column", type=str, help=""" The column to drop. """)
127    return parser
128
129
130def get_schema_parser() -> argshell.ArgShellParser:
131    """Returns info parser."""
132    parser = argshell.ArgShellParser()
133    parser.add_argument(
134        "tables",
135        type=str,
136        nargs="*",
137        default=[],
138        help=""" Only display info for this table(s). """,
139    )
140    parser.add_argument(
141        "-c",
142        "--rowcount",
143        action="store_true",
144        help=""" Count and display the number of rows for each table. """,
145    )
146    return parser
147
148
149def get_update_parser() -> argshell.ArgShellParser:
150    """Returns update parser."""
151    parser = argshell.ArgShellParser()
152    parser.add_argument("table", type=str, help=""" The table to update. """)
153    parser.add_argument("column", type=str, help=""" The column to update. """)
154    parser.add_argument(
155        "new_value", type=str, help=""" The value to update the column to. """
156    )
157    parser = add_where_argument(parser)
158    return parser
159
160
161def get_delete_parser() -> argshell.ArgShellParser:
162    """Returns delete parser."""
163    parser = argshell.ArgShellParser()
164    parser.add_argument("table", type=str, help=""" The table to delete from. """)
165    parser = add_where_argument(parser)
166    return parser
167
168
169def get_add_column_parser() -> argshell.ArgShellParser:
170    """Returns add column parser."""
171    parser = argshell.ArgShellParser()
172    parser.add_argument("table", type=str, help=""" The table to add a column to. """)
173    parser.add_argument(
174        "column_def",
175        type=str,
176        help=""" The column definition: "{name} {type} {constraints}" """,
177    )
178    return parser
179
180
181def get_scan_dbs_parser() -> argshell.ArgShellParser:
182    """Returns db scan parser."""
183    parser = argshell.ArgShellParser()
184    parser.add_argument(
185        "-e",
186        "--extensions",
187        type=str,
188        nargs="*",
189        default=[".db", ".sqlite3"],
190        help=""" A list of file extensions to scan for. By default, will scan for ".db" and ".sqlite3". """,
191    )
192    parser.add_argument(
193        "-r", "--recursive", action="store_true", help=""" Scan recursively. """
194    )
195    return parser
196
197
198def get_rename_table_parser() -> argshell.ArgShellParser:
199    """Returns rename table parser."""
200    parser = argshell.ArgShellParser()
201    parser.add_argument("table", type=str, help=""" The table to rename. """)
202    parser.add_argument("new_name", type=str, help=""" The new name for the table. """)
203    return parser
204
205
206def get_rename_column_parser() -> argshell.ArgShellParser:
207    """Returns rename column parser."""
208    parser = argshell.ArgShellParser()
209    parser.add_argument(
210        "table", type=str, help=""" The table with the column to rename. """
211    )
212    parser.add_argument("column", type=str, help=""" The column to rename. """)
213    parser.add_argument("new_name", type=str, help=""" The new name for the column. """)
214    return parser
215
216
217def get_add_table_parser() -> argshell.ArgShellParser:
218    """Returns a add_table parser."""
219    parser = argshell.ArgShellParser()
220    parser.add_argument("table", type=str, help=""" The new table's name. """)
221    parser.add_argument(
222        "columns",
223        type=str,
224        nargs="*",
225        help=""" The column definitions for the new table. Each individual column definition should be enclosed in quotes.
226        i.e. shell>add_table tablename "id INTEGER AUTOINCREMENT" "first_name TEXT" "last_name TEXT" "email TEXT UNIQUE" """,
227    )
228    return parser
229
230
231def get_dump_parser() -> argshell.ArgShellParser:
232    """Returns a dump parser."""
233    parser = argshell.ArgShellParser()
234    parser.add_argument(
235        "tables", type=str, nargs="*", default=None, help=""" The tables to dump. """
236    )
237    parser.add_argument(
238        "-s",
239        "--schema_only",
240        action="store_true",
241        help=""" Only create a schema dump file. """,
242    )
243    parser.add_argument(
244        "-d",
245        "--data_only",
246        action="store_true",
247        help=""" Only create a data dump file. """,
248    )
249    return parser
250
251
252def select_post_parser(args: argshell.Namespace) -> argshell.Namespace:
253    for field in ["group_by", "order_by"]:
254        arglist = getattr(args, field)
255        if arglist:
256            setattr(args, field, ", ".join(arglist))
257    return args
def add_where_argument( parser: argshell.argshell.ArgShellParser) -> argshell.argshell.ArgShellParser:
 7def add_where_argument(parser: argshell.ArgShellParser) -> argshell.ArgShellParser:
 8    """Add an optional `where` argument to the parser and return it.
 9
10    The added argument has a default value of `None` and has `nargs="?"`"""
11    parser.add_argument(
12        "where",
13        type=str,
14        default=None,
15        nargs="?",
16        help=""" The `WHERE` clause to use, if any. Don't include "WHERE" keyword in argument string. """,
17    )
18    return parser

Add an optional where argument to the parser and return it.

The added argument has a default value of None and has nargs="?"

def get_backup_parser() -> argshell.argshell.ArgShellParser:
21def get_backup_parser() -> argshell.ArgShellParser:
22    """Returns a parser for the backup command."""
23    parser = argshell.ArgShellParser()
24    parser.add_argument(
25        "-t",
26        "--timestamp",
27        action="store_true",
28        help=""" Add a timestamp to the backup file name to prevent overwriting previous backups. """,
29    )
30    return parser

Returns a parser for the backup command.

def get_select_parser() -> argshell.argshell.ArgShellParser:
33def get_select_parser() -> argshell.ArgShellParser:
34    """Returns a parser for use with `select`."""
35    parser = argshell.ArgShellParser()
36    parser.add_argument("table", type=str, help=""" The table to select from. """)
37    parser.add_argument(
38        "-c",
39        "--columns",
40        type=str,
41        default=["*"],
42        nargs="*",
43        help=""" The columns to select. If a column identifier has a space in it, like `COUNT(*) AS num_things`, enclose it in quotes. If no args given, `*` will be used. """,
44    )
45    parser.add_argument(
46        "-j",
47        "--joins",
48        type=str,
49        nargs="*",
50        default=None,
51        help=""" Joins to perform, if any. Should be in the form: `"{join type} JOIN {table2} ON {table}.{column} = {table2}.{column}"`. Enclose separate joins in quotes. """,
52    )
53    parser.add_argument(
54        "-w",
55        "--where",
56        type=str,
57        default=None,
58        help=""" The `WHERE` clause to use, if any. Don't include "WHERE" keyword in argument string. """,
59    )
60    parser.add_argument(
61        "-g",
62        "--group_by",
63        type=str,
64        default=None,
65        nargs="*",
66        help=""" The `GROUP BY` clause to use, if any. Don't include the keyword. """,
67    )
68    parser.add_argument(
69        "-H",
70        "--Having",
71        type=str,
72        default=None,
73        help=""" The `HAVING` clause to use, if any. Don't include keyword. """,
74    )
75    parser.add_argument(
76        "-o",
77        "--order_by",
78        type=str,
79        default=None,
80        nargs="*",
81        help=""" The `ORDER BY` clause to use, if any. Don't include keyword. """,
82    )
83    parser.add_argument(
84        "-l",
85        "--limit",
86        type=str,
87        default=None,
88        help=""" The `LIMIT` clause to use, if any. Don't include keyword. """,
89    )
90    parser.add_argument(
91        "-ec",
92        "--exclude_columns",
93        type=str,
94        nargs="*",
95        default=None,
96        help=""" Return all columns except these columns.""",
97    )
98    return parser

Returns a parser for use with select.

def get_count_parser() -> argshell.argshell.ArgShellParser:
101def get_count_parser() -> argshell.ArgShellParser:
102    """Returns a count parser."""
103    parser = argshell.ArgShellParser()
104    parser.add_argument("table", type=str, help=""" The table to count from. """)
105    parser = add_where_argument(parser)
106    parser.add_argument(
107        "-c",
108        "--column",
109        type=str,
110        default="*",
111        help=""" The column to count on. Default is `*`.""",
112    )
113    parser.add_argument(
114        "-d",
115        "--distinct",
116        action="store_true",
117        help=""" Whether the count should use `DISTINCT`.""",
118    )
119    return parser

Returns a count parser.

def get_drop_column_parser() -> argshell.argshell.ArgShellParser:
122def get_drop_column_parser() -> argshell.ArgShellParser:
123    parser = argshell.ArgShellParser()
124    parser.add_argument(
125        "table", type=str, help=""" The table to drop the column from. """
126    )
127    parser.add_argument("column", type=str, help=""" The column to drop. """)
128    return parser
def get_schema_parser() -> argshell.argshell.ArgShellParser:
131def get_schema_parser() -> argshell.ArgShellParser:
132    """Returns info parser."""
133    parser = argshell.ArgShellParser()
134    parser.add_argument(
135        "tables",
136        type=str,
137        nargs="*",
138        default=[],
139        help=""" Only display info for this table(s). """,
140    )
141    parser.add_argument(
142        "-c",
143        "--rowcount",
144        action="store_true",
145        help=""" Count and display the number of rows for each table. """,
146    )
147    return parser

Returns info parser.

def get_update_parser() -> argshell.argshell.ArgShellParser:
150def get_update_parser() -> argshell.ArgShellParser:
151    """Returns update parser."""
152    parser = argshell.ArgShellParser()
153    parser.add_argument("table", type=str, help=""" The table to update. """)
154    parser.add_argument("column", type=str, help=""" The column to update. """)
155    parser.add_argument(
156        "new_value", type=str, help=""" The value to update the column to. """
157    )
158    parser = add_where_argument(parser)
159    return parser

Returns update parser.

def get_delete_parser() -> argshell.argshell.ArgShellParser:
162def get_delete_parser() -> argshell.ArgShellParser:
163    """Returns delete parser."""
164    parser = argshell.ArgShellParser()
165    parser.add_argument("table", type=str, help=""" The table to delete from. """)
166    parser = add_where_argument(parser)
167    return parser

Returns delete parser.

def get_add_column_parser() -> argshell.argshell.ArgShellParser:
170def get_add_column_parser() -> argshell.ArgShellParser:
171    """Returns add column parser."""
172    parser = argshell.ArgShellParser()
173    parser.add_argument("table", type=str, help=""" The table to add a column to. """)
174    parser.add_argument(
175        "column_def",
176        type=str,
177        help=""" The column definition: "{name} {type} {constraints}" """,
178    )
179    return parser

Returns add column parser.

def get_scan_dbs_parser() -> argshell.argshell.ArgShellParser:
182def get_scan_dbs_parser() -> argshell.ArgShellParser:
183    """Returns db scan parser."""
184    parser = argshell.ArgShellParser()
185    parser.add_argument(
186        "-e",
187        "--extensions",
188        type=str,
189        nargs="*",
190        default=[".db", ".sqlite3"],
191        help=""" A list of file extensions to scan for. By default, will scan for ".db" and ".sqlite3". """,
192    )
193    parser.add_argument(
194        "-r", "--recursive", action="store_true", help=""" Scan recursively. """
195    )
196    return parser

Returns db scan parser.

def get_rename_table_parser() -> argshell.argshell.ArgShellParser:
199def get_rename_table_parser() -> argshell.ArgShellParser:
200    """Returns rename table parser."""
201    parser = argshell.ArgShellParser()
202    parser.add_argument("table", type=str, help=""" The table to rename. """)
203    parser.add_argument("new_name", type=str, help=""" The new name for the table. """)
204    return parser

Returns rename table parser.

def get_rename_column_parser() -> argshell.argshell.ArgShellParser:
207def get_rename_column_parser() -> argshell.ArgShellParser:
208    """Returns rename column parser."""
209    parser = argshell.ArgShellParser()
210    parser.add_argument(
211        "table", type=str, help=""" The table with the column to rename. """
212    )
213    parser.add_argument("column", type=str, help=""" The column to rename. """)
214    parser.add_argument("new_name", type=str, help=""" The new name for the column. """)
215    return parser

Returns rename column parser.

def get_add_table_parser() -> argshell.argshell.ArgShellParser:
218def get_add_table_parser() -> argshell.ArgShellParser:
219    """Returns a add_table parser."""
220    parser = argshell.ArgShellParser()
221    parser.add_argument("table", type=str, help=""" The new table's name. """)
222    parser.add_argument(
223        "columns",
224        type=str,
225        nargs="*",
226        help=""" The column definitions for the new table. Each individual column definition should be enclosed in quotes.
227        i.e. shell>add_table tablename "id INTEGER AUTOINCREMENT" "first_name TEXT" "last_name TEXT" "email TEXT UNIQUE" """,
228    )
229    return parser

Returns a add_table parser.

def get_dump_parser() -> argshell.argshell.ArgShellParser:
232def get_dump_parser() -> argshell.ArgShellParser:
233    """Returns a dump parser."""
234    parser = argshell.ArgShellParser()
235    parser.add_argument(
236        "tables", type=str, nargs="*", default=None, help=""" The tables to dump. """
237    )
238    parser.add_argument(
239        "-s",
240        "--schema_only",
241        action="store_true",
242        help=""" Only create a schema dump file. """,
243    )
244    parser.add_argument(
245        "-d",
246        "--data_only",
247        action="store_true",
248        help=""" Only create a data dump file. """,
249    )
250    return parser

Returns a dump parser.

def select_post_parser(args: argshell.argshell.Namespace) -> argshell.argshell.Namespace:
253def select_post_parser(args: argshell.Namespace) -> argshell.Namespace:
254    for field in ["group_by", "order_by"]:
255        arglist = getattr(args, field)
256        if arglist:
257            setattr(args, field, ", ".join(arglist))
258    return args