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    return parser
 90
 91
 92def get_count_parser() -> argshell.ArgShellParser:
 93    """Returns a count parser."""
 94    parser = argshell.ArgShellParser()
 95    parser.add_argument("table", type=str, help=""" The table to count from. """)
 96    parser = add_where_argument(parser)
 97    parser.add_argument(
 98        "-c",
 99        "--column",
100        type=str,
101        default="*",
102        help=""" The column to count on. Default is `*`.""",
103    )
104    parser.add_argument(
105        "-d",
106        "--distinct",
107        action="store_true",
108        help=""" Whether the count should use `DISTINCT`.""",
109    )
110    return parser
111
112
113def get_drop_column_parser() -> argshell.ArgShellParser:
114    parser = argshell.ArgShellParser()
115    parser.add_argument(
116        "table", type=str, help=""" The table to drop the column from. """
117    )
118    parser.add_argument("column", type=str, help=""" The column to drop. """)
119    return parser
120
121
122def get_schema_parser() -> argshell.ArgShellParser:
123    """Returns info parser."""
124    parser = argshell.ArgShellParser()
125    parser.add_argument(
126        "tables",
127        type=str,
128        nargs="*",
129        default=[],
130        help=""" Only display info for this table(s). """,
131    )
132    parser.add_argument(
133        "-c",
134        "--rowcount",
135        action="store_true",
136        help=""" Count and display the number of rows for each table. """,
137    )
138    return parser
139
140
141def get_update_parser() -> argshell.ArgShellParser:
142    """Returns update parser."""
143    parser = argshell.ArgShellParser()
144    parser.add_argument("table", type=str, help=""" The table to update. """)
145    parser.add_argument("column", type=str, help=""" The column to update. """)
146    parser.add_argument(
147        "new_value", type=str, help=""" The value to update the column to. """
148    )
149    parser = add_where_argument(parser)
150    return parser
151
152
153def get_delete_parser() -> argshell.ArgShellParser:
154    """Returns delete parser."""
155    parser = argshell.ArgShellParser()
156    parser.add_argument("table", type=str, help=""" The table to delete from. """)
157    parser = add_where_argument(parser)
158    return parser
159
160
161def get_add_column_parser() -> argshell.ArgShellParser:
162    """Returns add column parser."""
163    parser = argshell.ArgShellParser()
164    parser.add_argument("table", type=str, help=""" The table to add a column to. """)
165    parser.add_argument(
166        "column_def",
167        type=str,
168        help=""" The column definition: "{name} {type} {constraints}" """,
169    )
170    return parser
171
172
173def get_scan_dbs_parser() -> argshell.ArgShellParser:
174    """Returns db scan parser."""
175    parser = argshell.ArgShellParser()
176    parser.add_argument(
177        "-e",
178        "--extensions",
179        type=str,
180        nargs="*",
181        default=[".db", ".sqlite3"],
182        help=""" A list of file extensions to scan for. By default, will scan for ".db" and ".sqlite3". """,
183    )
184    parser.add_argument(
185        "-r", "--recursive", action="store_true", help=""" Scan recursively. """
186    )
187    return parser
188
189
190def get_rename_table_parser() -> argshell.ArgShellParser:
191    """Returns rename table parser."""
192    parser = argshell.ArgShellParser()
193    parser.add_argument("table", type=str, help=""" The table to rename. """)
194    parser.add_argument("new_name", type=str, help=""" The new name for the table. """)
195    return parser
196
197
198def get_rename_column_parser() -> argshell.ArgShellParser:
199    """Returns rename column parser."""
200    parser = argshell.ArgShellParser()
201    parser.add_argument(
202        "table", type=str, help=""" The table with the column to rename. """
203    )
204    parser.add_argument("column", type=str, help=""" The column to rename. """)
205    parser.add_argument("new_name", type=str, help=""" The new name for the column. """)
206    return parser
207
208
209def get_add_table_parser() -> argshell.ArgShellParser:
210    """Returns a add_table parser."""
211    parser = argshell.ArgShellParser()
212    parser.add_argument("table", type=str, help=""" The new table's name. """)
213    parser.add_argument(
214        "columns",
215        type=str,
216        nargs="*",
217        help=""" The column definitions for the new table. Each individual column definition should be enclosed in quotes.
218        i.e. shell>add_table tablename "id INTEGER AUTOINCREMENT" "first_name TEXT" "last_name TEXT" "email TEXT UNIQUE" """,
219    )
220    return parser
221
222
223def get_dump_parser() -> argshell.ArgShellParser:
224    """Returns a dump parser."""
225    parser = argshell.ArgShellParser()
226    parser.add_argument(
227        "tables", type=str, nargs="*", default=None, help=""" The tables to dump. """
228    )
229    parser.add_argument(
230        "-s",
231        "--schema_only",
232        action="store_true",
233        help=""" Only create a schema dump file. """,
234    )
235    parser.add_argument(
236        "-d",
237        "--data_only",
238        action="store_true",
239        help=""" Only create a data dump file. """,
240    )
241    return parser
242
243
244def select_post_parser(args: argshell.Namespace) -> argshell.Namespace:
245    for field in ["group_by", "order_by"]:
246        arglist = getattr(args, field)
247        if arglist:
248            setattr(args, field, ", ".join(arglist))
249    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    return parser

Returns a parser for use with select.

def get_count_parser() -> argshell.argshell.ArgShellParser:
 93def get_count_parser() -> argshell.ArgShellParser:
 94    """Returns a count parser."""
 95    parser = argshell.ArgShellParser()
 96    parser.add_argument("table", type=str, help=""" The table to count from. """)
 97    parser = add_where_argument(parser)
 98    parser.add_argument(
 99        "-c",
100        "--column",
101        type=str,
102        default="*",
103        help=""" The column to count on. Default is `*`.""",
104    )
105    parser.add_argument(
106        "-d",
107        "--distinct",
108        action="store_true",
109        help=""" Whether the count should use `DISTINCT`.""",
110    )
111    return parser

Returns a count parser.

def get_drop_column_parser() -> argshell.argshell.ArgShellParser:
114def get_drop_column_parser() -> argshell.ArgShellParser:
115    parser = argshell.ArgShellParser()
116    parser.add_argument(
117        "table", type=str, help=""" The table to drop the column from. """
118    )
119    parser.add_argument("column", type=str, help=""" The column to drop. """)
120    return parser
def get_schema_parser() -> argshell.argshell.ArgShellParser:
123def get_schema_parser() -> argshell.ArgShellParser:
124    """Returns info parser."""
125    parser = argshell.ArgShellParser()
126    parser.add_argument(
127        "tables",
128        type=str,
129        nargs="*",
130        default=[],
131        help=""" Only display info for this table(s). """,
132    )
133    parser.add_argument(
134        "-c",
135        "--rowcount",
136        action="store_true",
137        help=""" Count and display the number of rows for each table. """,
138    )
139    return parser

Returns info parser.

def get_update_parser() -> argshell.argshell.ArgShellParser:
142def get_update_parser() -> argshell.ArgShellParser:
143    """Returns update parser."""
144    parser = argshell.ArgShellParser()
145    parser.add_argument("table", type=str, help=""" The table to update. """)
146    parser.add_argument("column", type=str, help=""" The column to update. """)
147    parser.add_argument(
148        "new_value", type=str, help=""" The value to update the column to. """
149    )
150    parser = add_where_argument(parser)
151    return parser

Returns update parser.

def get_delete_parser() -> argshell.argshell.ArgShellParser:
154def get_delete_parser() -> argshell.ArgShellParser:
155    """Returns delete parser."""
156    parser = argshell.ArgShellParser()
157    parser.add_argument("table", type=str, help=""" The table to delete from. """)
158    parser = add_where_argument(parser)
159    return parser

Returns delete parser.

def get_add_column_parser() -> argshell.argshell.ArgShellParser:
162def get_add_column_parser() -> argshell.ArgShellParser:
163    """Returns add column parser."""
164    parser = argshell.ArgShellParser()
165    parser.add_argument("table", type=str, help=""" The table to add a column to. """)
166    parser.add_argument(
167        "column_def",
168        type=str,
169        help=""" The column definition: "{name} {type} {constraints}" """,
170    )
171    return parser

Returns add column parser.

def get_scan_dbs_parser() -> argshell.argshell.ArgShellParser:
174def get_scan_dbs_parser() -> argshell.ArgShellParser:
175    """Returns db scan parser."""
176    parser = argshell.ArgShellParser()
177    parser.add_argument(
178        "-e",
179        "--extensions",
180        type=str,
181        nargs="*",
182        default=[".db", ".sqlite3"],
183        help=""" A list of file extensions to scan for. By default, will scan for ".db" and ".sqlite3". """,
184    )
185    parser.add_argument(
186        "-r", "--recursive", action="store_true", help=""" Scan recursively. """
187    )
188    return parser

Returns db scan parser.

def get_rename_table_parser() -> argshell.argshell.ArgShellParser:
191def get_rename_table_parser() -> argshell.ArgShellParser:
192    """Returns rename table parser."""
193    parser = argshell.ArgShellParser()
194    parser.add_argument("table", type=str, help=""" The table to rename. """)
195    parser.add_argument("new_name", type=str, help=""" The new name for the table. """)
196    return parser

Returns rename table parser.

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

Returns rename column parser.

def get_add_table_parser() -> argshell.argshell.ArgShellParser:
210def get_add_table_parser() -> argshell.ArgShellParser:
211    """Returns a add_table parser."""
212    parser = argshell.ArgShellParser()
213    parser.add_argument("table", type=str, help=""" The new table's name. """)
214    parser.add_argument(
215        "columns",
216        type=str,
217        nargs="*",
218        help=""" The column definitions for the new table. Each individual column definition should be enclosed in quotes.
219        i.e. shell>add_table tablename "id INTEGER AUTOINCREMENT" "first_name TEXT" "last_name TEXT" "email TEXT UNIQUE" """,
220    )
221    return parser

Returns a add_table parser.

def get_dump_parser() -> argshell.argshell.ArgShellParser:
224def get_dump_parser() -> argshell.ArgShellParser:
225    """Returns a dump parser."""
226    parser = argshell.ArgShellParser()
227    parser.add_argument(
228        "tables", type=str, nargs="*", default=None, help=""" The tables to dump. """
229    )
230    parser.add_argument(
231        "-s",
232        "--schema_only",
233        action="store_true",
234        help=""" Only create a schema dump file. """,
235    )
236    parser.add_argument(
237        "-d",
238        "--data_only",
239        action="store_true",
240        help=""" Only create a data dump file. """,
241    )
242    return parser

Returns a dump parser.

def select_post_parser(args: argshell.argshell.Namespace) -> argshell.argshell.Namespace:
245def select_post_parser(args: argshell.Namespace) -> argshell.Namespace:
246    for field in ["group_by", "order_by"]:
247        arglist = getattr(args, field)
248        if arglist:
249            setattr(args, field, ", ".join(arglist))
250    return args