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        "-t",
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
113
114
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
127
128
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
139
140
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
147
148
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
159
160
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
176
177
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
184
185
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
195
196
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
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        "-t",
101        "--tables",
102        type=str,
103        nargs="*",
104        default=[],
105        help=""" Only display info for this table(s). """,
106    )
107    parser.add_argument(
108        "-c",
109        "--rowcount",
110        action="store_true",
111        help=""" Count and display the number of rows for each table. """,
112    )
113    return parser

Returns info parser.

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

Returns update parser.

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

Returns delete parser.

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

Returns add column parser.

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

Returns db scan parser.

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

Returns rename table parser.

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

Returns rename column parser.

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

Returns a add_table parser.