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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: relations-sqlite3
-Version: 0.6.9
+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.9 → 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.9
+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.9 → 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.9 → relations_sqlite3-0.6.10}/lib/relations_sqlite3.py

@@ -195,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):
@@ -252,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
 

{relations_sqlite3-0.6.9 → 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.9",
+    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.9 → 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())
@@ -1148,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())
@@ -1228,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: