relations-sqlite3 0.6.8__tar.gz → 0.6.10__tar.gz

{relations_sqlite3-0.6.8 → relations_sqlite3-0.6.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: relations-sqlite3
-Version: 0.6.8
+Version: 0.6.10
 Summary: DB Modeling for SQLite using the sqlite3 library
 Home-page: https://github.com/relations-dil/python-relations-sqlite3
 Author: Gaffer Fitch
@@ -9,7 +9,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: relations-dil>=0.6.13
+Requires-Dist: relations-dil>=0.6.16
 Requires-Dist: relations-sqlite>=0.6.3
 
 # relations-sqlite3

{relations_sqlite3-0.6.8 → relations_sqlite3-0.6.10}/lib/relations_sqlite3.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: relations-sqlite3
-Version: 0.6.8
+Version: 0.6.10
 Summary: DB Modeling for SQLite using the sqlite3 library
 Home-page: https://github.com/relations-dil/python-relations-sqlite3
 Author: Gaffer Fitch
@@ -9,7 +9,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: relations-dil>=0.6.13
+Requires-Dist: relations-dil>=0.6.16
 Requires-Dist: relations-sqlite>=0.6.3
 
 # relations-sqlite3

{relations_sqlite3-0.6.8 → relations_sqlite3-0.6.10}/lib/relations_sqlite3.egg-info/requires.txt

@@ -1,2 +1,2 @@
-relations-dil>=0.6.13
+relations-dil>=0.6.16
 relations-sqlite>=0.6.3

{relations_sqlite3-0.6.8 → relations_sqlite3-0.6.10}/lib/relations_sqlite3.py

@@ -29,7 +29,9 @@ class Source(relations_sql.SOURCE, relations.Source): # pylint: disable=too-many
     OP = relations_sqlite.OP
 
     AS = relations_sqlite.AS
+    OPTIONS = relations_sqlite.OPTIONS
     FIELDS = relations_sqlite.FIELDS
+    COLUMN_NAME = relations_sqlite.COLUMN_NAME
     TABLE = relations_sqlite.TABLE
     TABLE_NAME = relations_sqlite.TABLE_NAME
 
@@ -193,14 +195,30 @@ class Source(relations_sql.SOURCE, relations.Source): # pylint: disable=too-many
 
         return model
 
-    def retrieve_field(self, field, query):
+    def retrieve_record(self, record, query):
         """
-        Adds where caluse to query
+        Adds where clauses to query for all the fields in the record
+        """
+
+        for field in record._order:
+            self.retrieve_field(field, query, record)
+
+    def retrieve_field(self, field, query, record=None):
+        """
+        Adds where caluse to query, an injected field is looked up in the field it's stored in
         """
 
         for operator, value in (field.criteria or {}).items():
-            name = f"{field.store}__{operator}"
-            extracted = operator.rsplit("__", 1)[0] in (field.extract or {})
+
+            if field.inject:
+                stored, path = field.inject.split("__", 1)
+                stored = record._names[stored]
+                name = f"{stored.store}__{path}__{operator}"
+                extracted = path in (stored.extract or {})
+            else:
+                name = f"{field.store}__{operator}"
+                extracted = operator.rsplit("__", 1)[0] in (field.extract or {})
+
             query.WHERE(self.OP(name, value, EXTRACTED=extracted))
 
     def like(self, model, query):
@@ -250,7 +268,17 @@ class Source(relations_sql.SOURCE, relations.Source): # pylint: disable=too-many
         """
 
         for field in (model._sort or model._order or []):
-            query.ORDER_BY(**{field[1:]: (self.ASC if field[0] == "+" else self.DESC)})
+
+            name = field[1:]
+            field_name, path = (name.split("__", 1) + [None])[:2]
+
+            # an injected field is sorted by its path in the field it's stored in
+
+            if model._fields._names[field_name].inject:
+                stored, injected = model._fields._names[field_name].inject.split("__", 1)
+                name = f"{model._fields._names[stored].store}__{injected}" + (f"__{path}" if path else "")
+
+            query.ORDER_BY(**{name: (self.ASC if field[0] == "+" else self.DESC)})
 
         model._sort = None
 
@@ -278,6 +306,11 @@ class Source(relations_sql.SOURCE, relations.Source): # pylint: disable=too-many
         self.retrieve_record(model._record, query)
         self.like(model, query)
 
+        # a sibling-attribute flat join repeats a model tied to several matching siblings, so
+        # count the distinct model id instead of the joined rows
+        if getattr(model, "_distinct", False):
+            query.FIELDS = self.FIELDS(self.AS("total", self.SQL(f"COUNT(DISTINCT {model.STORE}.{model._id})")))
+
         return query
 
     def retrieve_query(self, model):
@@ -287,7 +320,12 @@ class Source(relations_sql.SOURCE, relations.Source): # pylint: disable=too-many
 
         query = self.count_query(model)
 
-        query.FIELDS = self.FIELDS("*")
+        # honor the flat-join DISTINCT marker: dedupe the model rows the join multiplied
+        if getattr(model, "_distinct", False):
+            query.OPTIONS = self.OPTIONS("DISTINCT")
+            query.FIELDS = self.FIELDS(self.COLUMN_NAME("*", table=model.STORE))
+        else:
+            query.FIELDS = self.FIELDS("*")
 
         self.sort(model, query)
         self.limit(model, query)

{relations_sqlite3-0.6.8 → relations_sqlite3-0.6.10}/setup.py

@@ -1,19 +1,26 @@
 #!/usr/bin/env python
 
+import os
 from setuptools import setup
 
 with open("README.md", "r") as readme_file:
     long_description = readme_file.read()
 
+version = os.environ.get("BUILD_VERSION")
+
+if version is None:
+    with open("VERSION", "r") as version_file:
+        version = version_file.read().strip()
+
 setup(
     name="relations-sqlite3",
-    version="0.6.8",
+    version=version,
     package_dir = {'': 'lib'},
     py_modules = [
         'relations_sqlite3'
     ],
     install_requires=[
-        'relations-dil>=0.6.13',
+        'relations-dil>=0.6.16',
         'relations-sqlite>=0.6.3'
     ],
     url="https://github.com/relations-dil/python-relations-sqlite3",

{relations_sqlite3-0.6.8 → relations_sqlite3-0.6.10}/test/test_relations_sqlite3.py

@@ -101,6 +101,17 @@ class SisBro(SourceModel):
 
 relations.ManyToMany(Sis, Bro, SisBro)
 
+class Owner(SourceModel):
+    id = int
+    name = str
+
+class Pet(SourceModel):
+    id = int
+    name = str
+    what = dict
+
+relations.OneToMany(Owner, Pet, child_inject="what")
+
 def dict_factory(cursor, row):
     d = {}
     for idx, col in enumerate(cursor.description):
@@ -218,6 +229,16 @@ CREATE UNIQUE INDEX `test_source`.`simple_name` ON `simple` (`name`);
 
         self.source.execute(self.source.define(Simple.thy().define()))
 
+        # an injected key isn't a column, it's stored in the dict field
+
+        self.source.execute(Owner.define())
+        self.source.execute(Pet.define())
+
+        cursor = self.source.connection.cursor()
+        cursor.execute("PRAGMA test_source.table_info(pet)")
+        self.assertEqual([column["name"] for column in cursor.fetchall()], ["id", "name", "what"])
+        cursor.close()
+
     def test_create_query(self):
 
         query = Simple("sure").query()
@@ -323,6 +344,27 @@ CREATE UNIQUE INDEX `test_source`.`simple_name` ON `simple` (`name`);
 
         cursor.close()
 
+        # an injected key is stored in the dict field, whether there's a parent or not
+
+        self.source.execute(Owner.define())
+        self.source.execute(Pet.define())
+
+        owner = Owner("pat")
+        owner.pet.add("rex")
+        owner.create()
+
+        stray = Pet("stray").create()
+
+        cursor = self.source.connection.cursor()
+        cursor.execute("SELECT * FROM test_source.pet ORDER BY name")
+        rows = [self.source.values_retrieve(stray, row) for row in cursor.fetchall()]
+        cursor.close()
+
+        self.assertEqual(rows, [
+            {"id": 1, "name": "rex", "what": {"relations": {"owner": {"id": owner.id}}}},
+            {"id": 2, "name": "stray", "what": {}}
+        ])
+
     def test_retrieve_field(self):
 
         field = relations.Field(int, name="id")
@@ -361,6 +403,37 @@ CREATE UNIQUE INDEX `test_source`.`simple_name` ON `simple` (`name`);
         self.assertEqual(query.sql, """SELECT WHERE `things__for__0____1`=?""")
         self.assertEqual(query.args, ['yes'])
 
+        # an injected key is looked up by its path in the field it's stored in
+
+        record = copy.deepcopy(Pet.thy()._fields)
+        field = record._names["owner_id"]
+        field.filter(1)
+        query = self.source.SELECT()
+        self.source.retrieve_field(field, query, record)
+        query.generate()
+        self.assertEqual(query.sql, """SELECT WHERE json_extract(`what`,?)=?""")
+        self.assertEqual(query.args, ['$.relations.owner.id', 1])
+
+        record = copy.deepcopy(Pet.thy()._fields)
+        field = record._names["owner_id"]
+        field.filter([1, 2], "in")
+        query = self.source.SELECT()
+        self.source.retrieve_field(field, query, record)
+        query.generate()
+        self.assertEqual(query.sql, """SELECT WHERE json_extract(`what`,?) IN (?,?)""")
+        self.assertEqual(query.args, ['$.relations.owner.id', 1, 2])
+
+    def test_retrieve_record(self):
+
+        record = copy.deepcopy(Pet.thy()._fields)
+        record._names["name"].filter("rex")
+        record._names["owner_id"].filter(1)
+        query = self.source.SELECT()
+        self.source.retrieve_record(record, query)
+        query.generate()
+        self.assertEqual(query.sql, """SELECT WHERE `name`=? AND json_extract(`what`,?)=?""")
+        self.assertEqual(query.args, ["rex", "$.relations.owner.id", 1])
+
     def test_like(self):
 
         self.source.execute(Unit.define())
@@ -448,6 +521,16 @@ CREATE UNIQUE INDEX `test_source`.`simple_name` ON `simple` (`name`);
         self.assertEqual(query.args, [])
         self.assertIsNone(unit._sort)
 
+        # an injected key sorts by its path in the field it's stored in
+
+        pet = Pet.many()
+        pet._sort = ['-owner_id']
+        query = self.source.SELECT()
+        self.source.sort(pet, query)
+        query.generate()
+        self.assertEqual(query.sql, """SELECT ORDER BY json_extract(`what`,?) DESC""")
+        self.assertEqual(query.args, ['$.relations.owner.id'])
+
     def test_limit(self):
 
         unit = Unit.one()
@@ -638,6 +721,19 @@ LIMIT ?""")
         self.assertEqual(Sis.many(bro_id=[tom.id]).count(), 1)
         self.assertEqual(Sis.many(bro_id=[999]).count(), 0)
 
+        # an injected key counts like any other
+
+        self.source.execute(Owner.define())
+        self.source.execute(Pet.define())
+
+        pat = Owner("pat").create()
+
+        Pet([{"name": "rex", "owner_id": pat.id}, {"name": "stray"}]).create()
+
+        self.assertEqual(Pet.many().count(), 2)
+        self.assertEqual(Pet.many(owner_id=pat.id).count(), 1)
+        self.assertEqual(Pet.many(owner_id=99).count(), 0)
+
     def test_values_retrieve(self):
 
         model = unittest.mock.MagicMock()
@@ -867,6 +963,37 @@ LIMIT ?""")
 
         self.assertEqual(len(Sis.many(bro_id=[999])), 0)
 
+        # an injected key retrieves, filters and relates like a column
+
+        self.source.execute(Owner.define())
+        self.source.execute(Pet.define())
+
+        pat = Owner("pat").create()
+        sam = Owner("sam").create()
+
+        Pet([
+            {"name": "rex", "owner_id": pat.id},
+            {"name": "fido", "owner_id": sam.id},
+            {"name": "spot", "owner_id": pat.id},
+            {"name": "stray"}
+        ]).create()
+
+        self.assertEqual(Pet.many(owner_id=pat.id).name, ["rex", "spot"])
+        self.assertEqual(Pet.many(owner_id__in=[pat.id, sam.id]).name, ["fido", "rex", "spot"])
+        self.assertEqual(Pet.many(owner_id__null=True).name, ["stray"])
+        self.assertEqual(Pet.many(owner_id=99).name, [])
+
+        self.assertEqual(Pet.one(name="rex").owner.name, "pat")
+        self.assertIsNone(Pet.one(name="stray").owner)
+
+        self.assertEqual(Owner.one(pat.id).pet.name, ["rex", "spot"])
+        self.assertEqual(Owner.one(name="pat").pet.name, ["rex", "spot"])
+
+        self.assertEqual(Pet.many(owner__name="pat").name, ["rex", "spot"])
+        self.assertEqual(Owner.many(pet__name="fido").name, ["sam"])
+
+        self.assertEqual(Pet.many(like="re").name, ["rex"])
+
     def test_retrieve_ties_query(self):
 
         self.source.execute(Sis.define())
@@ -917,6 +1044,52 @@ LIMIT ?""")
         self.assertEqual(Bro.many(sis_id__all=[jane.id, joan.id]).name, ["Bob"])
         self.assertEqual(Bro.many(sis_id__any=[joan.id]).name, ["Bob"])
 
+    def test_retrieve_ties_attr(self):
+
+        self.source.execute(Sis.define())
+        self.source.execute(Bro.define())
+        self.source.execute(SisBro.define())
+
+        # M2M attribute filtering: a flat join through the tie table filters on the sibling's
+        # own field. Existence semantics, with the sibling's normal field operators.
+
+        tom = Bro("Tom").create()
+        dick = Bro("Dick").create()
+        harry = Bro("Harry").create()
+
+        Sis("Mary", bro_id=[tom.id, dick.id]).create()   # tied to Tom, Dick
+        Sis("Sue", bro_id=[tom.id]).create()             # tied to Tom
+        Sis("Ann", bro_id=[dick.id, harry.id]).create()  # tied to Dick, Harry
+
+        # tied to a brother with that name
+        self.assertEqual(sorted(Sis.many(bro__name="Tom").name), ["Mary", "Sue"])
+        self.assertEqual(Sis.many(bro__name="Harry").name, ["Ann"])
+        self.assertEqual(len(Sis.many(bro__name="Ghost")), 0)
+
+        # field operators land on the sibling: like
+        self.assertEqual(Sis.many(bro__name__like="arr").name, ["Ann"])
+
+        # DISTINCT: Mary is tied to BOTH Tom and Dick, so an "in" join would match her twice;
+        # she must appear once (retrieve) and count once
+        self.assertEqual(sorted(Sis.many(bro__name__in=["Tom", "Dick"]).name), ["Ann", "Mary", "Sue"])
+        self.assertEqual(Sis.many(bro__name__in=["Tom", "Dick"]).count(), 3)
+
+        # negation is field-level: a tied non-Tom exists (Mary stays via Dick)
+        self.assertEqual(sorted(Sis.many(bro__name__not_in=["Tom"]).name), ["Ann", "Mary"])
+
+        # criteria on the same relation filter the SAME tied brother
+        self.assertEqual(Sis.many(bro__name="Dick", bro__id=harry.id).name, [])
+        self.assertEqual(sorted(Sis.many(bro__name="Dick", bro__id=dick.id).name), ["Ann", "Mary"])
+
+        # symmetric: brothers filtered by a tied sister's name
+        jane = Sis("Jane").create()
+        joan = Sis("Joan").create()
+        Bro("Bab", sis_id=[jane.id, joan.id]).create()   # tied to Jane, Joan
+        Bro("Bil", sis_id=[jane.id]).create()            # tied to Jane
+
+        self.assertEqual(sorted(Bro.many(sis__name="Jane").name), ["Bab", "Bil"])
+        self.assertEqual(Bro.many(sis__name__in=["Joan"]).name, ["Bab"])
+
     def test_titles(self):
 
         self.source.execute(Unit.define())
@@ -1102,6 +1275,34 @@ LIMIT ?""")
         self.assertEqual(Bro.one(name="Dick").sis.id, [dot.id])
         self.assertEqual(Sis.one(name="Nikki").bro.id, [tom.id])
 
+        # an injected key updates like a column, but not in mass
+
+        self.source.execute(Owner.define())
+        self.source.execute(Pet.define())
+
+        pat = Owner("pat").create()
+        sam = Owner("sam").create()
+
+        Pet([{"name": "rex", "owner_id": pat.id}, {"name": "fido", "owner_id": sam.id}]).create()
+
+        pet = Pet.one(name="rex").retrieve()
+        pet.owner_id = sam.id
+
+        self.assertEqual(pet.update(), 1)
+        self.assertEqual(Pet.one(name="rex").owner_id, sam.id)
+        self.assertEqual(Pet.many(owner_id=sam.id).name, ["fido", "rex"])
+
+        pet.owner_id = None
+
+        self.assertEqual(pet.update(), 1)
+        self.assertIsNone(Pet.one(name="rex").owner_id)
+        self.assertEqual(Pet.many(owner_id__null=True).name, ["rex"])
+
+        self.assertEqual(Pet.one(name="rex").set(owner_id=pat.id).update(), 1)
+        self.assertEqual(Pet.one(name="rex").owner_id, pat.id)
+
+        self.assertRaisesRegex(relations.FieldError, "no mass update with inject", Pet.many(name="rex").set(owner_id=sam.id).update)
+
     def test_delete_query(self):
 
         self.source.execute(Unit.define())
@@ -1182,6 +1383,18 @@ LIMIT ?""")
         self.assertEqual(Sis.one(name="Dot").bro.id, [tom.id])
         self.assertEqual(SisBro.many().count(), 1)
 
+        # an injected key deletes like any other
+
+        self.source.execute(Owner.define())
+        self.source.execute(Pet.define())
+
+        pat = Owner("pat").create()
+
+        Pet([{"name": "rex", "owner_id": pat.id}, {"name": "spot", "owner_id": pat.id}, {"name": "stray"}]).create()
+
+        self.assertEqual(Pet.many(owner_id=pat.id).delete(), 2)
+        self.assertEqual(Pet.many().name, ["stray"])
+
     def test_definition(self):
 
         with open("ddl/general.json", 'w') as ddl_file: