class _Getter:
+"Abstract class with dynamic attributes providing access to DB objects"
+def__init__(self, db): self.db = db
+# NB: Define `__dir__` in subclass to get list of objects
+def__repr__(self): return", ".join(dir(self))
+def__contains__(self, s): return (s ifisinstance(s,str) else s.name) indir(self)
+def__getitem__(self, idxs):
+ifisinstance(idxs,str): returnself.db.table(idxs)
+return [self.db.table(o) for o in idxs]
+def__getattr__(self, k):
+if k[0]=='_': raiseAttributeError
+returnself.db[k]
+
+class _TablesGetter(_Getter):
+def__dir__(self): returnself.db.table_names()
+
+@patch(as_prop=True)
+def t(self:Database): return _TablesGetter(self)
+
+
+
By returning a _TablesGetter we get a repr and auto-complete that shows all tables in the DB.
acdc = db.q(f"select * from {artist} where {ac.Name} like 'AC/%'")
+acdc
+
+
[{'ArtistId': 1, 'Name': 'AC/DC'}]
+
+
+
+
+Exported source
+
def _get_flds(tbl):
+return [(k, v|None, field(default=tbl.default_values.get(k,None)))
+for k,v in tbl.columns_dict.items()]
+
+def _dataclass(self:Table, store=True, suf='')->type:
+"Create a `dataclass` with the types and defaults of this table"
+ res = make_dataclass(self.name.title()+suf, _get_flds(self))
+if store: self.cls = res
+return res
+
+Table.dataclass = _dataclass
def all_dcs(db, with_views=False, store=True, suf=''):
+"dataclasses for all objects in `db`"
+return [o.dataclass(store=store, suf=suf) for o in db.tables + (db.views if with_views else [])]
def create_mod(db, mod_fn, with_views=False, store=True, suf=''):
+"Create module for dataclasses for `db`"
+ mod_fn =str(mod_fn)
+ifnot mod_fn.endswith('.py'): mod_fn+='.py'
+withopen(mod_fn, 'w') as f:
+print('from dataclasses import dataclass', file=f)
+print('from typing import Any,Union,Optional\n', file=f)
+for o in all_dcs(db, with_views, store=store, suf=suf): print(dataclass_src(o), file=f)
+
+
+
+
create_mod(db, 'db_dc')
+
+
+
from db_dc import Track
+Track(**dt.Track.get(1))
+
+
Track(TrackId=1, Name='For Those About To Rock (We Salute You)', AlbumId=1, MediaTypeId=1, GenreId=1, Composer='Angus Young, Malcolm Young, Brian Johnson', Milliseconds=343719, Bytes=11170334, UnitPrice=0.99)
+
+
+
+
+
+
call’]
+
*Built-in mutable sequence.
+
If no argument is given, the constructor creates a new empty list. The argument must be an iterable if specified.*
+
+
+Exported source
+
@patch
+def__call__(
+self:(Table|View), where:str|None=None,
+ where_args: Iterable|dict|NoneType=None, with_pk:bool=False, order_by: str|None=None,
+ limit:int|None=None, offset:int|None=None, as_cls:bool=True, **kwargs)->list:
+"Shortcut for `rows_where` or `pks_and_rows_where`, depending on `with_pk`"
+
+ f =getattr(self, 'pks_and_rows_where'if with_pk else'rows_where')
+ xtra =getattr(self, 'xtra_id', {})
+if xtra:
+ xw =' and '.join(f"[{k}] = {v!r}"for k,v in xtra.items())
+ where =f'{xw} and {where}'if where else xw
+ res = f(where=where, where_args=where_args, order_by=order_by, limit=limit, offset=offset, **kwargs)
+if as_cls andhasattr(self,'cls'):
+if with_pk: res = ((k,self.cls(**v)) for k,v in res)
+else: res = (self.cls(**o) for o in res)
+returnlist(res)
+
+
+
This calls either rows_where (if with_pk) or with_pk (otherwise). If dataclass(store=True) has been called, then if as_cls rows will be returned as dataclass objects.
Create table from cls, default name to snake-case version of class name
+
+
+
+
+
+
+
+
+
+
+
Type
+
Default
+
Details
+
+
+
+
+
cls
+
NoneType
+
None
+
Dataclass to create table from
+
+
+
name
+
NoneType
+
None
+
Name of table to create
+
+
+
pk
+
str
+
id
+
Column(s) to use as a primary key
+
+
+
foreign_keys
+
NoneType
+
None
+
Foreign key definitions
+
+
+
defaults
+
NoneType
+
None
+
Database table defaults
+
+
+
column_order
+
NoneType
+
None
+
Which columns should come first
+
+
+
not_null
+
NoneType
+
None
+
Columns that should be created as NOT NULL
+
+
+
hash_id
+
NoneType
+
None
+
Column to be used as a primary key using hash
+
+
+
hash_id_columns
+
NoneType
+
None
+
Columns used when calculating hash
+
+
+
extracts
+
NoneType
+
None
+
Columns to be extracted during inserts
+
+
+
if_not_exists
+
bool
+
False
+
Use CREATE TABLE IF NOT EXISTS
+
+
+
replace
+
bool
+
False
+
Drop and replace table if it already exists
+
+
+
ignore
+
bool
+
True
+
Silently do nothing if table already exists
+
+
+
transform
+
bool
+
False
+
If table exists transform it to fit schema
+
+
+
strict
+
bool
+
False
+
Apply STRICT mode to table
+
+
+
+
+
+Exported source
+
@patch
+def create(
+self: Database,
+ cls=None, # Dataclass to create table from
+ name=None, # Name of table to create
+ pk='id', # Column(s) to use as a primary key
+ foreign_keys=None, # Foreign key definitions
+ defaults=None, # Database table defaults
+ column_order=None, # Which columns should come first
+ not_null=None, # Columns that should be created as ``NOT NULL``
+ hash_id=None, # Column to be used as a primary key using hash
+ hash_id_columns=None, # Columns used when calculating hash
+ extracts=None, # Columns to be extracted during inserts
+ if_not_exists=False, # Use `CREATE TABLE IF NOT EXISTS`
+ replace=False, # Drop and replace table if it already exists
+ ignore=True, # Silently do nothing if table already exists
+ transform=False, # If table exists transform it to fit schema
+ strict=False, # Apply STRICT mode to table
+):
+"Create table from `cls`, default name to snake-case version of class name"
+ mk_dataclass(cls)
+if name isNone: name = camel2snake(cls.__name__)
+ typs = {o.name: o.typefor o in fields(cls)}
+ res =self.create_table(
+ name, typs, defaults=defaults,
+ pk=pk, foreign_keys=foreign_keys, column_order=column_order, not_null=not_null,
+ hash_id=hash_id, hash_id_columns=hash_id_columns, extracts=extracts, transform=transform,
+ if_not_exists=if_not_exists, replace=replace, ignore=ignore, strict=strict)
+ res.cls = cls
+return res
+
+
+
The class you pass to create is converted to a dataclass where any fields missing a default are defaulted to None.
