dataclassdb 0.1.0__py3-none-any.whl

dataclassdb/__init__.py

@@ -0,0 +1,19 @@
+from dataclassdb.dataclass_db import DataclassDb as DataclassDb
+from dataclassdb.db_engine import DbEngine as DbEngine
+from dataclassdb.builders.query_builder import QueryBuilder as QueryBuilder
+from dataclassdb.builders.string_builder import StringBuilder as StringBuilder
+from dataclassdb.dataclass_types import Codec as Codec
+from dataclassdb.dataclass_types import CustomCodec as CustomCodec
+from dataclassdb.dataclass_types import IsDataclass as IsDataclass
+from dataclassdb.constants import SQL as SQL
+from dataclassdb.constants import SQL_FUNC as SQL_FUNC
+from dataclassdb.constants import SQL_FUNC_PRAGMA as SQL_FUNC_PRAGMA
+from dataclassdb.constants import SQL_TYPES as SQL_TYPES
+from dataclassdb.dataclass_sqlite_table import (
+    DataclassTableCodec as DataclassTableCodec,
+)
+from dataclassdb.dataclass_sqlite_table import decode_dict as decode_dict
+from dataclassdb.dataclass_sqlite_table import decode_field as decode_field
+from dataclassdb.dataclass_sqlite_table import encode_field as encode_field
+from dataclassdb.dataclass_sqlite_table import get_class_codec as get_class_codec
+from dataclassdb.dataclass_sqlite_table import get_field_codec as get_field_codec

dataclassdb/builders/function_builder.py

@@ -0,0 +1,407 @@
+"""This script creates the getter and setter sql files from strenums."""
+
+__all__ = ['FunctionBuilder']
+
+from typing import Self
+
+from dataclassdb.builders.string_builder import StringBuilder
+from dataclassdb.constants import SQL_FUNC, SQL_FUNC_PRAGMA
+
+
+class FunctionBuilder(StringBuilder):
+    # Generated from scripts/generate_builder_files.py
+    def Abs(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.ABS, *args)
+
+    def Changes(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.CHANGES, *args)
+
+    def Char(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.CHAR, *args)
+
+    def Coalesce(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.COALESCE, *args)
+
+    def Concat(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.CONCAT, *args)
+
+    def Concat_ws(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.CONCAT_WS, *args)
+
+    def Format(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.FORMAT, *args)
+
+    def Glob(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.GLOB, *args)
+
+    def Hex(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.HEX, *args)
+
+    def If(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.IF, *args)
+
+    def Ifnull(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.IFNULL, *args)
+
+    def Iif(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.IIF, *args)
+
+    def Instr(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.INSTR, *args)
+
+    def Last_insert_rowid(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.LAST_INSERT_ROWID, *args)
+
+    def Length(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.LENGTH, *args)
+
+    def Like(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.LIKE, *args)
+
+    def Likelihood(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.LIKELIHOOD, *args)
+
+    def Likely(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.LIKELY, *args)
+
+    def Load_extension(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.LOAD_EXTENSION, *args)
+
+    def Lower(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.LOWER, *args)
+
+    def Ltrim(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.LTRIM, *args)
+
+    def Max(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.MAX, *args)
+
+    def Min(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.MIN, *args)
+
+    def Nullif(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.NULLIF, *args)
+
+    def Octet_length(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.OCTET_LENGTH, *args)
+
+    def Printf(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.PRINTF, *args)
+
+    def Quote(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.QUOTE, *args)
+
+    def Random(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.RANDOM, *args)
+
+    def Randomblob(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.RANDOMBLOB, *args)
+
+    def Replace(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.REPLACE, *args)
+
+    def Round(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.ROUND, *args)
+
+    def Rtrim(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.RTRIM, *args)
+
+    def Sign(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.SIGN, *args)
+
+    def Soundex(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.SOUNDEX, *args)
+
+    def Sqlite_compileoption_get(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.SQLITE_COMPILEOPTION_GET, *args)
+
+    def Sqlite_compileoption_used(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.SQLITE_COMPILEOPTION_USED, *args)
+
+    def Sqlite_offset(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.SQLITE_OFFSET, *args)
+
+    def Sqlite_source_id(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.SQLITE_SOURCE_ID, *args)
+
+    def Sqlite_version(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.SQLITE_VERSION, *args)
+
+    def Substr(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.SUBSTR, *args)
+
+    def Substring(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.SUBSTRING, *args)
+
+    def Total_changes(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.TOTAL_CHANGES, *args)
+
+    def Trim(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.TRIM, *args)
+
+    def Typeof(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.TYPEOF, *args)
+
+    def Unhex(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.UNHEX, *args)
+
+    def Unicode(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.UNICODE, *args)
+
+    def Unistr(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.UNISTR, *args)
+
+    def Unistr_quote(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.UNISTR_QUOTE, *args)
+
+    def Unlikely(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.UNLIKELY, *args)
+
+    def Upper(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.UPPER, *args)
+
+    def Zeroblob(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.ZEROBLOB, *args)
+
+    def Avg(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.AVG, *args)
+
+    def Group_concat(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.GROUP_CONCAT, *args)
+
+    def Median(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.MEDIAN, *args)
+
+    def Percentile(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.PERCENTILE, *args)
+
+    def Percentile_cont(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.PERCENTILE_CONT, *args)
+
+    def Percentile_disc(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.PERCENTILE_DISC, *args)
+
+    def String_agg(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.STRING_AGG, *args)
+
+    def Sum(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.SUM, *args)
+
+    def Total(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.TOTAL, *args)
+
+    def Count(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.COUNT, *args)
+
+    def Date(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.DATE, *args)
+
+    def Time(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.TIME, *args)
+
+    def Datetime(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.DATETIME, *args)
+
+    def Julianday(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.JULIANDAY, *args)
+
+    def Unixepoch(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.UNIXEPOCH, *args)
+
+    def Strftime(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.STRFTIME, *args)
+
+    def Timediff(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.TIMEDIFF, *args)
+
+    def Integer(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.INTEGER, *args)
+
+    def Text(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.TEXT, *args)
+
+    def Blob(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.BLOB, *args)
+
+    def Real(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.REAL, *args)
+
+    def Numeric(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.NUMERIC, *args)
+
+    def Any(self, *args) -> Self:
+        return self.add_func(SQL_FUNC.ANY, *args)
+
+    def Analysis_limit(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.ANALYSIS_LIMIT, *args)
+
+    def Application_id(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.APPLICATION_ID, *args)
+
+    def Auto_vacuum(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.AUTO_VACUUM, *args)
+
+    def Automatic_index(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.AUTOMATIC_INDEX, *args)
+
+    def Busy_timeout(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.BUSY_TIMEOUT, *args)
+
+    def Cache_size(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.CACHE_SIZE, *args)
+
+    def Cache_spill(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.CACHE_SPILL, *args)
+
+    def Cell_size_check(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.CELL_SIZE_CHECK, *args)
+
+    def Checkpoint_fullfsync(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.CHECKPOINT_FULLFSYNC, *args)
+
+    def Collation_list(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.COLLATION_LIST, *args)
+
+    def Compile_options(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.COMPILE_OPTIONS, *args)
+
+    def Data_version(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.DATA_VERSION, *args)
+
+    def Database_list(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.DATABASE_LIST, *args)
+
+    def Defer_foreign_keys(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.DEFER_FOREIGN_KEYS, *args)
+
+    def Encoding(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.ENCODING, *args)
+
+    def Foreign_key_check(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.FOREIGN_KEY_CHECK, *args)
+
+    def Foreign_key_list(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.FOREIGN_KEY_LIST, *args)
+
+    def Foreign_keys(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.FOREIGN_KEYS, *args)
+
+    def Freelist_count(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.FREELIST_COUNT, *args)
+
+    def Fullfsync(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.FULLFSYNC, *args)
+
+    def Function_list(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.FUNCTION_LIST, *args)
+
+    def Hard_heap_limit(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.HARD_HEAP_LIMIT, *args)
+
+    def Ignore_check_constraints(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.IGNORE_CHECK_CONSTRAINTS, *args)
+
+    def Incremental_vacuum(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.INCREMENTAL_VACUUM, *args)
+
+    def Index_info(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.INDEX_INFO, *args)
+
+    def Index_list(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.INDEX_LIST, *args)
+
+    def Index_xinfo(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.INDEX_XINFO, *args)
+
+    def Integrity_check(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.INTEGRITY_CHECK, *args)
+
+    def Journal_mode(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.JOURNAL_MODE, *args)
+
+    def Journal_size_limit(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.JOURNAL_SIZE_LIMIT, *args)
+
+    def Legacy_alter_table(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.LEGACY_ALTER_TABLE, *args)
+
+    def Legacy_file_format(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.LEGACY_FILE_FORMAT, *args)
+
+    def Locking_mode(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.LOCKING_MODE, *args)
+
+    def Max_page_count(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.MAX_PAGE_COUNT, *args)
+
+    def Mmap_size(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.MMAP_SIZE, *args)
+
+    def Module_list(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.MODULE_LIST, *args)
+
+    def Optimize(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.OPTIMIZE, *args)
+
+    def Page_count(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.PAGE_COUNT, *args)
+
+    def Page_size(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.PAGE_SIZE, *args)
+
+    def Pragma_list(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.PRAGMA_LIST, *args)
+
+    def Query_only(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.QUERY_ONLY, *args)
+
+    def Quick_check(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.QUICK_CHECK, *args)
+
+    def Read_uncommitted(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.READ_UNCOMMITTED, *args)
+
+    def Recursive_triggers(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.RECURSIVE_TRIGGERS, *args)
+
+    def Reverse_unordered_selects(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.REVERSE_UNORDERED_SELECTS, *args)
+
+    def Secure_delete(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.SECURE_DELETE, *args)
+
+    def Shrink_memory(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.SHRINK_MEMORY, *args)
+
+    def Soft_heap_limit(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.SOFT_HEAP_LIMIT, *args)
+
+    def Synchronous(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.SYNCHRONOUS, *args)
+
+    def Table_info(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.TABLE_INFO, *args)
+
+    def Table_list(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.TABLE_LIST, *args)
+
+    def Table_xinfo(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.TABLE_XINFO, *args)
+
+    def Temp_store(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.TEMP_STORE, *args)
+
+    def Threads(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.THREADS, *args)
+
+    def Trusted_schema(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.TRUSTED_SCHEMA, *args)
+
+    def User_version(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.USER_VERSION, *args)
+
+    def Wal_autocheckpoint(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.WAL_AUTOCHECKPOINT, *args)
+
+    def Wal_checkpoint(self, *args) -> Self:
+        return self.add_func(SQL_FUNC_PRAGMA.WAL_CHECKPOINT, *args)

dataclassdb/builders/list_utils.py

@@ -0,0 +1,48 @@
+from dataclasses import is_dataclass
+
+__all__ = ["flatten", "add_commas", "add_parenthesis", "add_quotes", "placeholders"]
+
+
+
+def _flatten_generator(*args):
+    for arg in args:
+        if isinstance(arg, list) | isinstance(arg, tuple):
+            yield from _flatten_generator(*arg)
+        else:
+            yield arg
+
+
+def flatten(*args):
+    return list(_flatten_generator(*args))
+
+
+def add_commas(*args):
+    params = flatten(*args)
+    if len(params) > 1:
+        params[:-1] = [f"{param}," for param in params[:-1]]
+    return params
+
+
+def add_parenthesis(*args):
+    params = flatten(*args)
+    params = [item.__name__ if is_dataclass(item) else item for item in params]
+    if not params:
+        return ["()"]
+    elif len(params) == 1:
+        params[0] = f"({params[0]})"
+    else:
+        params[0] = f"({params[0]}"
+        params[-1] = f"{params[-1]})"
+    return params
+
+
+def add_quotes(*args):
+    params = [f'"{item}"' for item in flatten(*args)]
+    return params
+
+
+def placeholders(*args, count = None):
+    if count:
+        return ["?"] * count
+    else:
+        return ["?"] * len(flatten(*args)) if args else []

dataclassdb/builders/query_builder.py

@@ -0,0 +1,158 @@
+__all__ = ["QueryBuilder"]
+from typing import Self
+
+import dataclassdb.builders.list_utils as lu
+from dataclassdb.builders.function_builder import FunctionBuilder
+from dataclassdb.builders.statement_builder import StatementBuilder
+from dataclassdb.db_engine import DbEngine
+from dataclassdb.dataclass_types import IsDataclass
+from dataclassdb.utils import PragmaTableInfo
+
+
+class QueryBuilder(DbEngine, StatementBuilder, FunctionBuilder):
+    _affinity_map = {
+        "INT": "INTEGER",
+        "INTEGER": "INTEGER",
+        "TINYINT": "INTEGER",
+        "SMALLINT": "INTEGER",
+        "MEDIUMINT": "INTEGER",
+        "BIGINT": "INTEGER",
+        "UNSIGNED BIG INT": "INTEGER",
+        "INT2": "INTEGER",
+        "INT8": "INTEGER",
+        "CHARACTER": "TEXT",
+        "VARCHAR": "TEXT",
+        "VARYING CHARACTER": "TEXT",
+        "NCHAR": "TEXT",
+        "NVARCHAR": "TEXT",
+        "TEXT": "TEXT",
+        "CLOB": "TEXT",
+        "BLOB": "BLOB",
+        "REAL": "REAL",
+        "DOUBLE": "REAL",
+        "DOUBLE PRECISION": "REAL",
+        "FLOAT": "REAL",
+        "NUMERIC": "REAL",
+        "DECIMAL": "REAL",
+        "BOOLEAN": "INTEGER",
+        "DATE": "TEXT",  # Overridden
+        "DATETIME": "TEXT",  # Overridden
+    }
+
+    @property
+    def eq(self) -> Self:
+        return self.add("=")
+
+    @property
+    def neq(self) -> Self:
+        return self.add("<>")
+
+    @property
+    def lpar(self) -> Self:
+        return self.add("(")
+
+    @property
+    def rpar(self) -> Self:
+        return self.add(")")
+
+    @property
+    def comma(self) -> Self:
+        if self.query:
+            self.query[-1] = f"{self.query[-1]},"
+        else:
+            self.query.append(",")
+        return self
+
+    @property
+    def end(self):
+        if self.query:
+            self.query[-1] = f"{self.query[-1]};"
+        else:
+            self.query.append(";")
+        return self
+
+    def par(self, *args, commas=True, quotes=False) -> Self:
+        return self.add(*args, commas=commas, quotes=quotes, par=True)
+
+    def quote(self, *args, commas=True, par=False) -> Self:
+        return self.add(*args, commas=commas, quotes=True, par=par)
+
+    def dot(self, rside: str = "") -> Self:
+        """Appends `.{rside}` to the right of the last item in the query."""
+        dot_str = f".{rside}"
+        if self.query:
+            self.query[-1] = f"{self.query[-1]}{dot_str}"
+        else:
+            self.add(dot_str)
+        return self
+
+    def placeholders(self, *args, count=None, par=True) -> Self:
+        return self.add(lu.placeholders(*args, count=count), par=par)
+
+    def get_current_fields(self, _data_class) -> list[PragmaTableInfo]:
+        query = QueryBuilder().PRAGMA.Table_info(_data_class)
+        output = self.execute(sql_str=str(query), as_dict=True)
+        return PragmaTableInfo.from_list(output)
+
+    def get_curr_cols(self, _data_class) -> list[str]:
+        row = (
+            QueryBuilder(self.connection)
+            .SELECT("sql")
+            .FROM("sqlite_schema")
+            .WHERE("name")
+            .eq.quote(_data_class)
+            # .AND("name")
+            # .eq.quote(_data_class)
+        ).execute_one()
+        if not row:
+            return []
+
+        cols = row[0].split("(", 1)[-1].rsplit(")", 1)[0].split(",")
+        cols = [col.replace("\n", "").strip() for col in cols]
+        return cols
+
+    def select(self, *args):
+        """This version of select handles the case where dot notation
+        is used in a select.
+        `SELECT user.id -> SELECT user.id AS [user.id]`
+        Without this change sqlite will ignore the prefix when creating
+        the output row.
+        """
+        params = []
+        for arg in args:
+            if "." in arg:
+                params.append(f"{arg} AS [{arg}]")
+            else:
+                params.append(arg)
+        return self.SELECT(*params)
+
+    def from_(self, table: str | IsDataclass, as_=""):
+        self.FROM(table)
+        if as_:
+            self.AS(as_)
+        return self
+
+    def join(
+        self, table: str | IsDataclass, as_="", on="", using_cols=[], join_type=""
+    ):
+        if on and using_cols:
+            raise SyntaxError("Cannot have both 'ON' and 'USING' statements in a join.")
+        if join_type:
+            self(join_type)
+        self.JOIN(table)
+        if as_:
+            self.AS(as_)
+        if on:
+            self.ON(on)
+        elif using_cols:
+            self.USING(lu.flatten(using_cols), par=True)
+        return self
+
+    @staticmethod
+    def get_sql_col_affinity(col_name) -> str | None:
+        if "(" in col_name:
+            col = col_name.split("(")[0]
+        else:
+            col = col_name
+
+        return QueryBuilder._affinity_map.get(col, None)