databased.dbparsers

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

Returns a parser for the backup command.

def get_select_parser() -> argshell.argshell.ArgShellParser:
19def get_select_parser() -> argshell.ArgShellParser:
20    """Returns a parser for use with `select`."""
21    parser = argshell.ArgShellParser()
22    parser.add_argument("table", type=str, help=""" The table to select from. """)
23    parser.add_argument(
24        "-c",
25        "--columns",
26        type=str,
27        default=["*"],
28        nargs="*",
29        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. """,
30    )
31    parser.add_argument(
32        "-j",
33        "--joins",
34        type=str,
35        nargs="*",
36        default=None,
37        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. """,
38    )
39    parser.add_argument(
40        "-w",
41        "--where",
42        type=str,
43        default=None,
44        help=""" The `WHERE` clause to use, if any. Don't include "WHERE" keyword in argument string. """,
45    )
46    parser.add_argument(
47        "-g",
48        "--group_by",
49        type=str,
50        default=None,
51        nargs="*",
52        help=""" The `GROUP BY` clause to use, if any. Don't include the keyword. """,
53    )
54    parser.add_argument(
55        "-H",
56        "--Having",
57        type=str,
58        default=None,
59        help=""" The `HAVING` clause to use, if any. Don't include keyword. """,
60    )
61    parser.add_argument(
62        "-o",
63        "--order_by",
64        type=str,
65        default=None,
66        nargs="*",
67        help=""" The `ORDER BY` clause to use, if any. Don't include keyword. """,
68    )
69    parser.add_argument(
70        "-l",
71        "--limit",
72        type=str,
73        default=None,
74        help=""" The `LIMIT` clause to use, if any. Don't include keyword. """,
75    )
76    return parser

Returns a parser for use with select.

def select_post_parser(args: argshell.argshell.Namespace) -> argshell.argshell.Namespace:
79def select_post_parser(args: argshell.Namespace) -> argshell.Namespace:
80    for field in ["group_by", "order_by"]:
81        arglist = getattr(args, field)
82        if arglist:
83            setattr(args, field, ", ".join(arglist))
84    return args
def get_drop_column_parser() -> argshell.argshell.ArgShellParser:
87def get_drop_column_parser() -> argshell.ArgShellParser:
88    parser = argshell.ArgShellParser()
89    parser.add_argument(
90        "table", type=str, help=""" The table to drop the column from. """
91    )
92    parser.add_argument("column", type=str, help=""" The column to drop. """)
93    return parser
def get_schema_parser() -> argshell.argshell.ArgShellParser:
 96def get_schema_parser() -> argshell.ArgShellParser:
 97    """Returns info parser."""
 98    parser = argshell.ArgShellParser()
 99    parser.add_argument(
100        "tables",
101        type=str,
102        nargs="*",
103        default=[],
104        help=""" Only display info for this table(s). """,
105    )
106    parser.add_argument(
107        "-c",
108        "--rowcount",
109        action="store_true",
110        help=""" Count and display the number of rows for each table. """,
111    )
112    return parser

Returns info parser.

def add_where_argument( parser: argshell.argshell.ArgShellParser) -> argshell.argshell.ArgShellParser:
115def add_where_argument(parser: argshell.ArgShellParser) -> argshell.ArgShellParser:
116    """Add an optional `where` argument to the parser and return it.
117
118    The added argument has a default value of `None` and has `nargs="?"`"""
119    parser.add_argument(
120        "where",
121        type=str,
122        default=None,
123        nargs="?",
124        help=""" The `WHERE` clause to use, if any. Don't include "WHERE" keyword in argument string. """,
125    )
126    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_update_parser() -> argshell.argshell.ArgShellParser:
129def get_update_parser() -> argshell.ArgShellParser:
130    """Returns update parser."""
131    parser = argshell.ArgShellParser()
132    parser.add_argument("table", type=str, help=""" The table to update. """)
133    parser.add_argument("column", type=str, help=""" The column to update. """)
134    parser.add_argument(
135        "new_value", type=str, help=""" The value to update the column to. """
136    )
137    parser = add_where_argument(parser)
138    return parser

Returns update parser.

def get_delete_parser() -> argshell.argshell.ArgShellParser:
141def get_delete_parser() -> argshell.ArgShellParser:
142    """Returns delete parser."""
143    parser = argshell.ArgShellParser()
144    parser.add_argument("table", type=str, help=""" The table to delete from. """)
145    parser = add_where_argument(parser)
146    return parser

Returns delete parser.

def get_add_column_parser() -> argshell.argshell.ArgShellParser:
149def get_add_column_parser() -> argshell.ArgShellParser:
150    """Returns add column parser."""
151    parser = argshell.ArgShellParser()
152    parser.add_argument("table", type=str, help=""" The table to add a column to. """)
153    parser.add_argument(
154        "column_def",
155        type=str,
156        help=""" The column definition: "{name} {type} {constraints}" """,
157    )
158    return parser

Returns add column parser.

def get_scan_dbs_parser() -> argshell.argshell.ArgShellParser:
161def get_scan_dbs_parser() -> argshell.ArgShellParser:
162    """Returns db scan parser."""
163    parser = argshell.ArgShellParser()
164    parser.add_argument(
165        "-e",
166        "--extensions",
167        type=str,
168        nargs="*",
169        default=[".db", ".sqlite3"],
170        help=""" A list of file extensions to scan for. By default, will scan for ".db" and ".sqlite3". """,
171    )
172    parser.add_argument(
173        "-r", "--recursive", action="store_true", help=""" Scan recursively. """
174    )
175    return parser

Returns db scan parser.

def get_rename_table_parser() -> argshell.argshell.ArgShellParser:
178def get_rename_table_parser() -> argshell.ArgShellParser:
179    """Returns rename table parser."""
180    parser = argshell.ArgShellParser()
181    parser.add_argument("table", type=str, help=""" The table to rename. """)
182    parser.add_argument("new_name", type=str, help=""" The new name for the table. """)
183    return parser

Returns rename table parser.

def get_rename_column_parser() -> argshell.argshell.ArgShellParser:
186def get_rename_column_parser() -> argshell.ArgShellParser:
187    """Returns rename column parser."""
188    parser = argshell.ArgShellParser()
189    parser.add_argument(
190        "table", type=str, help=""" The table with the column to rename. """
191    )
192    parser.add_argument("column", type=str, help=""" The column to rename. """)
193    parser.add_argument("new_name", type=str, help=""" The new name for the column. """)
194    return parser

Returns rename column parser.

def get_add_table_parser() -> argshell.argshell.ArgShellParser:
197def get_add_table_parser() -> argshell.ArgShellParser:
198    """Returns a add_table parser."""
199    parser = argshell.ArgShellParser()
200    parser.add_argument("table", type=str, help=""" The new table's name. """)
201    parser.add_argument(
202        "columns",
203        type=str,
204        nargs="*",
205        help=""" The column definitions for the new table. Each individual column definition should be enclosed in quotes.
206        i.e. shell>add_table tablename "id INTEGER AUTOINCREMENT" "first_name TEXT" "last_name TEXT" "email TEXT UNIQUE" """,
207    )
208    return parser

Returns a add_table parser.

def get_dump_parser() -> argshell.argshell.ArgShellParser:
211def get_dump_parser() -> argshell.ArgShellParser:
212    """Returns a dump parser."""
213    parser = argshell.ArgShellParser()
214    parser.add_argument(
215        "tables", type=str, nargs="*", default=None, help=""" The tables to dump. """
216    )
217    parser.add_argument(
218        "-s",
219        "--schema_only",
220        action="store_true",
221        help=""" Only create a schema dump file. """,
222    )
223    parser.add_argument(
224        "-d",
225        "--data_only",
226        action="store_true",
227        help=""" Only create a data dump file. """,
228    )
229    return parser

Returns a dump parser.