Fixes and enhancements

Author: maximebf

docs/instrumentation.md

@@ -10,7 +10,7 @@ from sqlorm.opentelemetry import SQLORMInstrumentor
 SQLORMInstrumentor().instrument(engine=engine)
 ```
 
-You can optionally configure SQLAlchemy instrumentation to enable sqlcommenter which enriches the query with contextual information.
+You can optionally configure SQLORM instrumentation to enable sqlcommenter which enriches the query with contextual information.
 
 ```py
 SQLORMInstrumentor().instrument(enable_commenter=True, commenter_options={})

docs/models.md

@@ -248,7 +248,7 @@ By default, unknown columns (ones which are not mapped), will be set as attribut
 Dirty attributes which are not mapped will also be saved in DML statements.
 
 You can thus create models with no mapped columns. However, models require a primary key to function properly.
-One will be automatically added when non are defined (named "id").
+One will be automatically added when none are defined (named "id").
 
 When no columns are mapped, `SELECT *` is used.
 

sqlorm/doc.py

@@ -0,0 +1,13 @@
+import abc
+from .model import Model, Column
+from .types import JSON
+
+
+class DocModel(Model, abc.ABC):
+    fields = Column(JSON)
+
+    def __getattr__(self, name):
+        pass
+
+    def __setattr__(self, name, value):
+        pass

sqlorm/drivers/sqlite.py

@@ -14,15 +14,21 @@
 }
 
 
+PRIMARY_KEY_SCHEMA_DEFINITION = "PRIMARY KEY AUTOINCREMENT"
+
+
 def connect(*args, **kwargs):
     pragmas = kwargs.pop("pragma", {})
     extensions = kwargs.pop("ext", None)
     fine_tune = kwargs.pop("fine_tune", False)
+    foreign_keys = kwargs.pop("foreign_keys", False)
 
     kwargs.setdefault("check_same_thread", False)  # better default to work with sqlorm pooling
     conn = sqlite3.connect(*args, **kwargs)
     conn.row_factory = sqlite3.Row
 
+    if foreign_keys:
+        pragmas["foreign_keys"] = "ON"
     if fine_tune:
         pragmas.update(FINE_TUNED_PRAGMAS)
 

sqlorm/engine.py

@@ -509,7 +509,7 @@ def fetchcomposite(
             map = HydrationMap.create([model, nested])
         elif nested:
             map = CompositionMap(
-                lambda r: r.values(), {k: HydrationMap.create(v) for k, v in nested.items()}
+                lambda r: list(r.values()), {k: HydrationMap.create(v) for k, v in nested.items()}
             )
         elif not map:
             map = CompositionMap.create([loader, nested])

sqlorm/mapper.py

@@ -39,7 +39,7 @@ def from_class(cls, object_class, **kwargs):
             if value.__class__ is t._AnnotatedAlias:
                 primary_key = PrimaryKeyColumn in getattr(value, "__metadata__", ())
                 value = value.__args__[0]
-            mapper.columns.append(
+            mapper.map(key, 
                 Column(key, SQLType.from_pytype(value), primary_key=primary_key, attribute=key)
             )
         return mapper
@@ -58,6 +58,7 @@ def map(self, attr, col_or_rel=None):
         if isinstance(col_or_rel, MappedColumnMixin):
             col_or_rel.attribute = attr
             col_or_rel.mapper = self
+            col_or_rel.table = self.table
             self.columns.append(col_or_rel)
         elif isinstance(col_or_rel, Relationship):
             col_or_rel.attribute = attr
@@ -296,13 +297,28 @@ def delete(self, obj):
 
     def __repr__(self):
         return f"<Mapper({self.table} -> {self.object_class.__name__})>"
+    
+
+class _Unknown:
+    pass
+unknown = _Unknown()
 
 
 class MapperColumnList(ColumnList):
     def __init__(self, mapper):
         super().__init__([], wildcard=None)
         self.mapper = mapper
 
+    def aliased_table(self, alias=unknown):
+        if alias is unknown:
+            alias = self.mapper.table
+        return super().aliased_table(alias)
+    
+    def prefixed(self, prefix=unknown):
+        if prefix is unknown:
+            prefix = f"{self.mapper.object_class.__name__}__"
+        return super().prefixed(prefix)
+
     def get(self, name):
         for col in self:
             if col.name == name:
@@ -331,6 +347,7 @@ def __init__(
         unique=False,
         lazy=False,
         attribute=None,
+        schema_def=None
     ):
         self.name = name
         self.table = None
@@ -344,6 +361,7 @@ def __init__(
         self.unique = unique
         self.lazy = lazy
         self.attribute = attribute
+        self.schema_def = schema_def
 
     def get(self, obj):
         """Returns the database value from the object, using the provided dump function if needed

sqlorm/model.py

@@ -41,12 +41,16 @@ def process_mapped_attributes(dct):
         mapped_attrs = {}
         for name, annotation in dct.get("__annotations__", {}).items():
             primary_key = False
+            nullable = None
             if annotation.__class__ is t._AnnotatedAlias:
                 primary_key = PrimaryKeyColumn in getattr(annotation, "__metadata__", ())
                 annotation = annotation.__args__[0]
+            if annotation.__class__ is t.Optional:
+                annotation = annotation.__args__[0]
+                nullable = True
             if name not in dct:
                 # create column object for annotations with no default values
-                dct[name] = mapped_attrs[name] = Column(name, annotation, primary_key=primary_key)
+                dct[name] = mapped_attrs[name] = Column(name, annotation, primary_key=primary_key, nullable=nullable)
             elif isinstance(dct[name], Column):
                 mapped_attrs[name] = dct[name]
                 if dct[name].type is None:
@@ -112,6 +116,10 @@ def create_mapper(cls, mapped_attrs=None):
         if mapped_attrs:
             cls.__mapper__.map(mapped_attrs)
 
+        for col in cls.__mapper__.columns:
+            if col.nullable is None:
+                col.nullable = cls.Meta.columns_default_nullable
+
         cls.c = cls.__mapper__.columns  # handy shortcut
 
         auto_primary_key = cls.Meta.auto_primary_key
@@ -120,7 +128,9 @@ def create_mapper(cls, mapped_attrs=None):
                 # we force the usage of SELECT * as we auto add a primary key without any other mapped columns
                 # without doing this, only the primary key would be selected
                 cls.__mapper__.force_select_wildcard = True
-            cls.__mapper__.map(auto_primary_key, Column(auto_primary_key, type=cls.Meta.auto_primary_key_type, primary_key=True))
+            pk_column = Column(auto_primary_key, type=cls.Meta.auto_primary_key_type, primary_key=True, nullable=False)
+            cls.__mapper__.map(auto_primary_key, pk_column)
+            setattr(cls, auto_primary_key, pk_column)
 
     @staticmethod
     def process_meta_inheritance(cls):
@@ -340,6 +350,7 @@ class Meta:
         )
         auto_primary_key_type: SQLType = Integer
         allow_unknown_columns: bool = True  # hydrate() will set attributes for unknown columns
+        columns_default_nullable : bool = True
 
     @classmethod
     def bind(cls, engine: Engine):
@@ -349,6 +360,9 @@ def bind(cls, engine: Engine):
             (cls, abc.ABC),
             {"__engine__": engine, "__model_registry__": ModelRegistry()},
         )
+    
+    def __sql__(self):
+        return self.table.name
 
 
 class Model(BaseModel, abc.ABC):

sqlorm/schema.py

@@ -1,7 +1,7 @@
 from .model import BaseModel
 from .sql import SQL, split_sql_statements
 from .sqlfunc import execute
-from .engine import ensure_transaction
+from .engine import ensure_transaction, get_current_session
 from .mapper import Mapper
 import os
 import re
@@ -39,17 +39,18 @@ def create_all(model_registry=None, engine=None, check_missing=False, logger=Non
 def create_table(mapper, default_type="varchar"):
     if not isinstance(mapper, Mapper):
         mapper = Mapper.from_class(mapper)
+    dbapi = get_current_session().engine.dbapi
     return SQL(
         "CREATE TABLE",
         mapper.table,
         SQL.Tuple(
             [
-                SQL(
+                SQL(c.schema_def) if c.schema_def else SQL(
                     c.name,
                     c.type.sql_type if c.type else default_type,
                     "UNIQUE" if c.unique else "",
                     "NOT NULL" if not c.nullable else "",
-                    "PRIMARY KEY" if c.primary_key else "",
+                    getattr(dbapi, "PRIMARY_KEY_SCHEMA_DEFINITION", "PRIMARY KEY") if c.primary_key else "",
                     SQL(
                         "REFERENCES",
                         f"{c.references.table} ({c.references.name})"
@@ -146,3 +147,16 @@ def set_schema_version(version, engine=None):
                     SQL.insert("schema_version", {"version": version}),
                 )
             )
+
+
+def create_initial_migration(model_registry=None, path="migrations", version="000", **kwargs):
+    if not model_registry:
+        model_registry = BaseModel.__model_registry__
+
+    stmts = []
+    for model in model_registry.values():
+        stmts.append(create_table.sql(model.__mapper__, **kwargs))
+
+    sql = "-- Initial creation of the database (auto-generated by sqlorm)\n\n" + ";\n\n".join(stmts)
+    with open(os.path.join(path, f"{version}_initial.sql"), "w") as f:
+        f.write(sql)

sqlorm/sql.py

@@ -1,5 +1,6 @@
 import typing as t
 from collections import namedtuple
+from collections.abc import Iterable
 
 
 def render(stmt, params=None, dbapi=None, paramstyle=None):
@@ -113,6 +114,8 @@ def _render(self, params):
         for part in self.parts:
             if isinstance(part, SQLStr):
                 stmt.append(str(part._render(params)))
+            elif hasattr(part, "__sql__"):
+                stmt.append(str(part.__sql__()))
             elif part:
                 stmt.append(str(part))
         return " ".join(filter(bool, stmt))
@@ -354,8 +357,9 @@ def as_dict(self):
 class List(SQLStr, list):
     """A list of SQL items"""
 
-    def __init__(self, items=None, joinstr=",", startstr="", endstr=""):
-        super().__init__(items)
+    def __init__(self, *items, joinstr=",", startstr="", endstr=""):
+        _items = items[0] if len(items) == 1 and isinstance(items[0], Iterable) else items
+        super().__init__(_items)
         self.joinstr = joinstr
         self.startstr = startstr
         self.endstr = endstr
@@ -374,18 +378,18 @@ def _render(self, params):
 
 
 class And(List):
-    def __init__(self, items):
-        super().__init__(items, "AND", "(", ")")
+    def __init__(self, *items):
+        super().__init__(*items, joinstr="AND", startstr="(", endstr=")")
 
 
 class Or(List):
-    def __init__(self, items):
-        super().__init__(items, "OR", "(", ")")
+    def __init__(self, *items):
+        super().__init__(*items, joinstr="OR", startstr="(", endstr=")")
 
 
 class Tuple(List):
-    def __init__(self, items):
-        super().__init__(items, ",", "(", ")")
+    def __init__(self, *items):
+        super().__init__(*items, joinstr=",", startstr="(", endstr=")")
 
 
 class Function(SQLStr):

sqlorm/sqlfunc.py

@@ -44,7 +44,7 @@ def is_sqlfunc(func):
     """Checks if func is an empty function with a python doc"""
     doc = inspect.getdoc(func)
     src = inspect.getsource(func).strip(' "\n\r')
-    return doc and src.endswith(func.__doc__) and not getattr(func, "sqlfunc", False)
+    return doc and src.endswith(func.__doc__.strip(' \n\r')) and not getattr(func, "sqlfunc", False)
 
 
 def _query_executor_builder(executor):