relations-sqlite3 0.6.7__tar.gz → 0.6.9__tar.gz

{relations-sqlite3-0.6.7 → relations_sqlite3-0.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: relations-sqlite3
-Version: 0.6.7
+Version: 0.6.9
 Summary: DB Modeling for SQLite using the sqlite3 library
 Home-page: https://github.com/relations-dil/python-relations-sqlite3
 Author: Gaffer Fitch
@@ -9,6 +9,8 @@ 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-sqlite>=0.6.3
 
 # relations-sqlite3
 

{relations-sqlite3-0.6.7 → relations_sqlite3-0.6.9}/lib/relations_sqlite3.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: relations-sqlite3
-Version: 0.6.7
+Version: 0.6.9
 Summary: DB Modeling for SQLite using the sqlite3 library
 Home-page: https://github.com/relations-dil/python-relations-sqlite3
 Author: Gaffer Fitch
@@ -9,6 +9,8 @@ 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-sqlite>=0.6.3
 
 # relations-sqlite3
 

relations_sqlite3-0.6.9/lib/relations_sqlite3.egg-info/requires.txt

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

{relations-sqlite3-0.6.7 → relations_sqlite3-0.6.9}/lib/relations_sqlite3.py

@@ -14,7 +14,7 @@ import relations
 import relations_sql
 import relations_sqlite
 
-class Source(relations.Source): # pylint: disable=too-many-public-methods
+class Source(relations_sql.SOURCE, relations.Source): # pylint: disable=too-many-public-methods
     """
     sqlite3 Source
     """
@@ -29,7 +29,9 @@ class Source(relations.Source): # pylint: disable=too-many-public-methods
     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
 
@@ -128,7 +130,7 @@ class Source(relations.Source): # pylint: disable=too-many-public-methods
         Get query for what's being inserted
         """
 
-        fields = [field.store for field in model._fields._order if not field.auto and not field.inject]
+        fields = [field.store for field in model._fields._order if not field.auto and not field.inject and field.store]
         query = self.INSERT(self.TABLE_NAME(model.STORE, schema=model.SCHEMA), *fields)
 
         if not model._bulk and model._id is not None and model._fields._names[model._id].auto:
@@ -157,6 +159,8 @@ class Source(relations.Source): # pylint: disable=too-many-public-methods
         Executes the create
         """
 
+        super().create(model)
+
         cursor = self.connection.cursor()
 
         if not model._bulk and model._id is not None and model._fields._names[model._id].auto:
@@ -173,6 +177,10 @@ class Source(relations.Source): # pylint: disable=too-many-public-methods
         if not model._bulk:
 
             for creating in model._each("create"):
+
+                if model._id:
+                    self.create_ties(creating)
+
                 for parent_child in creating.CHILDREN:
                     if creating._children.get(parent_child):
                         creating._children[parent_child].create()
@@ -217,10 +225,10 @@ class Source(relations.Source): # pylint: disable=too-many-public-methods
             parent = False
 
             for relation in model.PARENTS.values():
-                if field.name == relation.child_field:
+                if field.name == relation.child_parent_ref:
                     parent = relation.Parent.many(like=model._like).limit(model._chunk)
-                    if parent[relation.parent_field]:
-                        titles(self.IN(field.store, parent[relation.parent_field]))
+                    if parent[relation.parent_id]:
+                        titles(self.IN(field.store, parent[relation.parent_id]))
                         model.overflow = model.overflow or parent.overflow
                     else:
                         parent = True
@@ -268,9 +276,15 @@ class Source(relations.Source): # pylint: disable=too-many-public-methods
         query = self.SELECT(self.AS("total", self.SQL("COUNT(*)"))).FROM(self.TABLE_NAME(model.STORE, schema=model.SCHEMA))
 
         model._collate()
+        self.collate_ties_query(model, query)
         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):
@@ -280,7 +294,12 @@ class Source(relations.Source): # pylint: disable=too-many-public-methods
 
         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)
@@ -299,6 +318,8 @@ class Source(relations.Source): # pylint: disable=too-many-public-methods
         Executes the count
         """
 
+        super().count(model)
+
         cursor = self.connection.cursor()
 
         if query is None:
@@ -330,6 +351,8 @@ class Source(relations.Source): # pylint: disable=too-many-public-methods
         Executes the retrieve
         """
 
+        super().retrieve(model)
+
         cursor = self.connection.cursor()
 
         if query is None:
@@ -368,6 +391,8 @@ class Source(relations.Source): # pylint: disable=too-many-public-methods
 
         model._action = "update"
 
+        self.retrieve_ties(model)
+
         cursor.close()
 
         return model
@@ -428,6 +453,8 @@ class Source(relations.Source): # pylint: disable=too-many-public-methods
         Executes the update
         """
 
+        super().update(model)
+
         cursor = self.connection.cursor()
 
         updated = 0
@@ -438,9 +465,29 @@ class Source(relations.Source): # pylint: disable=too-many-public-methods
 
             update_query = query or self.update_query(model)
 
-            update_query.generate()
-            cursor.execute(update_query.sql, update_query.args)
-            updated = cursor.rowcount
+            if update_query.SET.expressions:
+
+                update_query.generate()
+                cursor.execute(update_query.sql, update_query.args)
+                updated += cursor.rowcount
+
+            ties = model._record.tie({})
+
+            if ties:
+
+                store_id = model._fields._names[model._id].store
+
+                id_query = self.SELECT(store_id, WHERE=update_query.WHERE).FROM(self.TABLE_NAME(model.STORE, schema=model.SCHEMA))
+
+                id_query.generate()
+
+                cursor.execute(id_query.sql, id_query.args)
+                ids = [row[store_id] for row in cursor.fetchall()]
+
+                self.delete_ties(model, ids)
+                self.create_ties(model, ties, ids)
+
+                updated = len(ids)
 
         elif model._id:
 
@@ -448,17 +495,21 @@ class Source(relations.Source): # pylint: disable=too-many-public-methods
 
                 update_query = query or self.update_query(updating)
 
-                if update_query.SET:
+                if update_query.SET.expressions:
 
                     update_query.generate()
                     cursor.execute(update_query.sql, update_query.args)
+                    updated += cursor.rowcount
+
+
+
+                self.delete_ties(updating)
+                self.create_ties(updating)
 
                 for parent_child in updating.CHILDREN:
                     if updating._children.get(parent_child):
                         updating._children[parent_child].create().update()
 
-                updated += cursor.rowcount
-
         else:
 
             raise relations.ModelError(model, "nothing to update from")
@@ -482,6 +533,7 @@ class Source(relations.Source): # pylint: disable=too-many-public-methods
             store = model._fields._names[model._id].store
             for deleting in model._each():
                 ids.append(deleting[model._id])
+
             query.WHERE(**{f"{store}__in": ids})
 
         else:
@@ -495,9 +547,38 @@ class Source(relations.Source): # pylint: disable=too-many-public-methods
         Executes the delete
         """
 
+        super().delete(model)
+
         cursor = self.connection.cursor()
 
-        delete_query = query or self.delete_query(model)
+        if model._action == "retrieve":
+
+            delete_query = query or self.delete_query(model)
+
+            if model._id:
+
+                store_id = model._fields._names[model._id].store
+
+                id_query = self.SELECT(store_id, WHERE=delete_query.WHERE).FROM(self.TABLE_NAME(model.STORE, schema=model.SCHEMA))
+
+                id_query.generate()
+
+                cursor.execute(id_query.sql, id_query.args)
+                ids = [row[store_id] for row in cursor.fetchall()]
+
+                self.delete_ties(model, ids)
+
+        elif model._id:
+
+            delete_query = self.delete_query(model)
+
+            for deleting in model._each():
+                if self.has_ties(deleting):
+                    self.delete_ties(deleting)
+
+        else:
+
+            raise relations.ModelError(model, "nothing to delete from")
 
         delete_query.generate()
         cursor.execute(delete_query.sql, tuple(delete_query.args))

{relations-sqlite3-0.6.7 → relations_sqlite3-0.6.9}/setup.py

@@ -7,14 +7,14 @@ with open("README.md", "r") as readme_file:
 
 setup(
     name="relations-sqlite3",
-    version="0.6.7",
+    version="0.6.9",
     package_dir = {'': 'lib'},
     py_modules = [
         'relations_sqlite3'
     ],
     install_requires=[
-        'relations-dil>=0.6.12',
-        'relations-sqlite>=0.6.2'
+        'relations-dil>=0.6.13',
+        'relations-sqlite>=0.6.3'
     ],
     url="https://github.com/relations-dil/python-relations-sqlite3",
     author="Gaffer Fitch",

{relations-sqlite3-0.6.7 → relations_sqlite3-0.6.9}/test/test_relations_sqlite3.py

@@ -84,6 +84,23 @@ class Case(SourceModel):
 relations.OneToMany(Unit, Test)
 relations.OneToOne(Test, Case)
 
+class Sis(SourceModel):
+    id = int
+    name = str
+    bro_id = set
+
+class Bro(SourceModel):
+    id = int
+    name = str
+    sis_id = set
+
+class SisBro(SourceModel):
+    ID = None
+    bro_id = int
+    sis_id = int
+
+relations.ManyToMany(Sis, Bro, SisBro)
+
 def dict_factory(cursor, row):
     d = {}
     for idx, col in enumerate(cursor.description):
@@ -218,6 +235,12 @@ CREATE UNIQUE INDEX `test_source`.`simple_name` ON `simple` (`name`);
         model = Simple([["sure"], ["fine"]])
         self.assertRaisesRegex(relations.ModelError, "only one create query at a time", model.query)
 
+        query = Sis("sure", bro_id=[1, 2, 3]).query()
+        query.generate()
+
+        self.assertEqual(query.sql, """INSERT INTO `test_source`.`sis` (`name`) VALUES (?)""")
+        self.assertEqual(query.args, ["sure"])
+
     def test_create_id(self):
 
         self.source.execute(Simple.define())
@@ -282,6 +305,22 @@ CREATE UNIQUE INDEX `test_source`.`simple_name` ON `simple` (`name`);
             "things__for__0____1": "yep"
         })
 
+        sis = Sis("Sally", bro_id=[2, 3, 4], _bulk=True)
+        self.assertRaisesRegex(relations.ModelError, "cannot create ties in bulk", sis.create)
+
+        self.source.execute(Sis.define())
+        self.source.execute(Bro.define())
+        self.source.execute(SisBro.define())
+
+        sis = Sis("Sally", bro_id=[2, 3, 4]).create()
+
+        cursor.execute("SELECT * FROM test_source.sis_bro ORDER BY bro_id")
+        self.assertEqual(cursor.fetchall(), [
+            {"sis_id": sis.id, "bro_id": 2},
+            {"sis_id": sis.id, "bro_id": 3},
+            {"sis_id": sis.id, "bro_id": 4}
+        ])
+
         cursor.close()
 
     def test_retrieve_field(self):
@@ -588,6 +627,17 @@ LIMIT ?""")
 
         self.assertEqual(Unit.many(like="p").count(), 1)
 
+        self.source.execute(Sis.define())
+        self.source.execute(Bro.define())
+        self.source.execute(SisBro.define())
+
+        tom = Bro("Tom").create()
+        Sis("Sally", bro_id=[tom.id]).create()
+        Sis("Mary").create()
+
+        self.assertEqual(Sis.many(bro_id=[tom.id]).count(), 1)
+        self.assertEqual(Sis.many(bro_id=[999]).count(), 0)
+
     def test_values_retrieve(self):
 
         model = unittest.mock.MagicMock()
@@ -636,6 +686,9 @@ LIMIT ?""")
         self.source.execute(Case.define())
         self.source.execute(Meta.define())
         self.source.execute(Net.define())
+        self.source.execute(Sis.define())
+        self.source.execute(Bro.define())
+        self.source.execute(SisBro.define())
 
         Unit([["stuff"], ["people"]]).create()
 
@@ -794,6 +847,122 @@ LIMIT ?""")
         model = Net.many(subnet__max_value=int(ipaddress.IPv4Address('1.2.3.0')))
         self.assertEqual(len(model), 0)
 
+        tom = Bro("Tom").create()
+        dick = Bro("Dick").create()
+
+        dot = Sis("Dot").create()
+        nikki = Sis("Nikki").create()
+
+        mary = Sis("Mary", bro_id=[tom.id, dick.id]).create()
+        harry = Bro("Harry", sis_id=[dot.id, nikki.id]).create()
+
+        self.assertEqual(mary.bro.id, [dick.id, tom.id])
+        self.assertEqual(harry.sis.id, [dot.id, nikki.id])
+
+        self.assertEqual(len(Sis.many(bro_id=[tom.id])), 1)
+        self.assertEqual(Sis.many(bro_id=[tom.id])[0].name, "Mary")
+
+        self.assertEqual(len(Bro.many(sis_id=[dot.id])), 1)
+        self.assertEqual(Bro.many(sis_id=[dot.id])[0].name, "Harry")
+
+        self.assertEqual(len(Sis.many(bro_id=[999])), 0)
+
+    def test_retrieve_ties_query(self):
+
+        self.source.execute(Sis.define())
+        self.source.execute(Bro.define())
+        self.source.execute(SisBro.define())
+
+        # The tie field is a set, so it's queried with set operators (has/any/all),
+        # resolved through the tie table. A sister has many brothers, so "any of" and
+        # "all of" are genuinely different queries.
+
+        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
+
+        # has: tied to that one brother
+        self.assertEqual(sorted(Sis.many(bro_id__has=tom.id).name), ["Mary", "Sue"])
+        self.assertEqual(Sis.many(bro_id__has=harry.id).name, ["Ann"])
+        self.assertEqual(len(Sis.many(bro_id__has=999)), 0)
+
+        # any: tied to at least one of them
+        self.assertEqual(sorted(Sis.many(bro_id__any=[tom.id, harry.id]).name), ["Ann", "Mary", "Sue"])
+        self.assertEqual(Sis.many(bro_id__any=[harry.id]).name, ["Ann"])
+        self.assertEqual(len(Sis.many(bro_id__any=[999])), 0)
+
+        # all: tied to every one of them
+        self.assertEqual(Sis.many(bro_id__all=[tom.id, dick.id]).name, ["Mary"])
+        self.assertEqual(sorted(Sis.many(bro_id__all=[dick.id]).name), ["Ann", "Mary"])
+        self.assertEqual(len(Sis.many(bro_id__all=[tom.id, harry.id])), 0)
+
+        # all must de-dupe the requested list (a repeated value can't change the result)
+        self.assertEqual(sorted(Sis.many(bro_id__all=[dick.id, dick.id]).name), ["Ann", "Mary"])
+
+        # negation
+        self.assertEqual(Sis.many(bro_id__not_has=tom.id).name, ["Ann"])
+        self.assertEqual(sorted(Sis.many(bro_id__not_any=[harry.id]).name), ["Mary", "Sue"])
+
+        # symmetric: brothers queried by their tied sisters
+        jane = Sis("Jane").create()
+        joan = Sis("Joan").create()
+        Bro("Bob", sis_id=[jane.id, joan.id]).create()   # tied to Jane, Joan
+        Bro("Bill", sis_id=[jane.id]).create()           # tied to Jane
+
+        self.assertEqual(sorted(Bro.many(sis_id__has=jane.id).name), ["Bill", "Bob"])
+        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())
@@ -801,6 +970,9 @@ LIMIT ?""")
         self.source.execute(Case.define())
         self.source.execute(Meta.define())
         self.source.execute(Net.define())
+        self.source.execute(Sis.define())
+        self.source.execute(Bro.define())
+        self.source.execute(SisBro.define())
 
         Unit("people").create().test.add("stuff").add("things").create()
 
@@ -838,6 +1010,11 @@ LIMIT ?""")
             1: ["1.2.3.4"]
         })
 
+        tom = Bro("Tom").create()
+        Sis("Sally", bro_id=[tom.id]).create()
+
+        self.assertEqual(len(Sis.many(bro_id=[tom.id]).titles().ids), 1)
+
     def test_update_field(self):
 
         # Standard
@@ -901,6 +1078,9 @@ LIMIT ?""")
         self.source.execute(Case.define())
         self.source.execute(Meta.define())
         self.source.execute(Net.define())
+        self.source.execute(Sis.define())
+        self.source.execute(Bro.define())
+        self.source.execute(SisBro.define())
 
         Unit([["people"], ["stuff"]]).create()
 
@@ -943,6 +1123,31 @@ LIMIT ?""")
         self.assertEqual(Net.one(ping.id).ip.compressed, "13.14.15.16")
         self.assertEqual(Net.one(pong.id).ip.compressed, "5.6.7.8")
 
+        Sis("Sally").create()
+        bro = Bro("Harry").create()
+        Sis.many(name="Sally").set(bro_id=[bro.id]).update()
+
+        sis = Sis.one(name="Sally")
+
+        self.assertEqual(Bro.one(name="Harry").sis.id, [sis.id])
+
+        tom = Bro("Tom").create()
+        dick = Bro("Dick").create()
+
+        dot = Sis("Dot").create()
+        nikki = Sis("Nikki").create()
+
+        tom.sis_id = [nikki.id, dot.id]
+        dot.bro_id = [tom.id, dick.id]
+
+        tom.update()
+        dot.update()
+
+        self.assertEqual(Bro.one(name="Tom").sis.id, [dot.id, nikki.id])
+        self.assertEqual(Sis.one(name="Dot").bro.id, [dick.id, tom.id])
+        self.assertEqual(Bro.one(name="Dick").sis.id, [dot.id])
+        self.assertEqual(Sis.one(name="Nikki").bro.id, [tom.id])
+
     def test_delete_query(self):
 
         self.source.execute(Unit.define())
@@ -974,6 +1179,9 @@ LIMIT ?""")
         self.source.execute(Test.define())
         self.source.execute(Case.define())
         self.source.execute(Plain.define())
+        self.source.execute(Sis.define())
+        self.source.execute(Bro.define())
+        self.source.execute(SisBro.define())
 
         unit = Unit("people")
         unit.test.add("stuff").add("things")
@@ -992,6 +1200,34 @@ LIMIT ?""")
         plain = Plain(0, "nope").create()
         self.assertRaisesRegex(relations.ModelError, "plain: nothing to delete from", plain.delete)
 
+        Sis("Sally").create()
+        bro = Bro("Harry").create()
+        Sis.many(name="Sally").set(bro_id=[bro.id]).update()
+
+        Sis.many(name="Sally").delete()
+
+        self.assertEqual(Bro.one(name="Harry").sis.id, [])
+        self.assertEqual(SisBro.many().count(), 0)
+
+        tom = Bro("Tom").create()
+        dick = Bro("Dick").create()
+
+        dot = Sis("Dot").create()
+        nikki = Sis("Nikki").create()
+
+        tom.sis_id = [nikki.id, dot.id]
+        dot.bro_id = [tom.id, dick.id]
+
+        tom.update()
+        dot.update()
+
+        Bro.one(name="Dick").retrieve().delete()
+        Sis.one(name="Nikki").retrieve().delete()
+
+        self.assertEqual(Bro.one(name="Tom").sis.id, [dot.id])
+        self.assertEqual(Sis.one(name="Dot").bro.id, [tom.id])
+        self.assertEqual(SisBro.many().count(), 1)
+
     def test_definition(self):
 
         with open("ddl/general.json", 'w') as ddl_file:

relations-sqlite3-0.6.7/lib/relations_sqlite3.egg-info/requires.txt

@@ -1,2 +0,0 @@
-relations-dil>=0.6.12
-relations-sqlite>=0.6.2