relations-sqlite3 0.6.11__tar.gz → 0.6.12__tar.gz

{relations_sqlite3-0.6.11 → relations_sqlite3-0.6.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relations-sqlite3
-Version: 0.6.11
+Version: 0.6.12
 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.18
+Requires-Dist: relations-dil>=0.6.19
 Requires-Dist: relations-sqlite>=0.6.4
 Dynamic: author
 Dynamic: author-email

{relations_sqlite3-0.6.11 → relations_sqlite3-0.6.12}/lib/relations_sqlite3.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: relations-sqlite3
-Version: 0.6.11
+Version: 0.6.12
 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.18
+Requires-Dist: relations-dil>=0.6.19
 Requires-Dist: relations-sqlite>=0.6.4
 Dynamic: author
 Dynamic: author-email

{relations_sqlite3-0.6.11 → relations_sqlite3-0.6.12}/lib/relations_sqlite3.egg-info/requires.txt

@@ -1,2 +1,2 @@
-relations-dil>=0.6.18
+relations-dil>=0.6.19
 relations-sqlite>=0.6.4

{relations_sqlite3-0.6.11 → relations_sqlite3-0.6.12}/lib/relations_sqlite3.py

@@ -143,6 +143,19 @@ class Source(relations_sql.SOURCE, relations.Source): # pylint: disable=too-many
 
         return query
 
+    @staticmethod
+    def write(cursor, model, sql, args):
+        """
+        Executes a write, a duplicate is relations' unique error, with the driver's error as its cause
+        """
+
+        try:
+            cursor.execute(sql, args)
+        except sqlite3.IntegrityError as exception:
+            if str(exception).startswith("UNIQUE constraint failed"):
+                raise relations.UniqueError(model, str(exception)) from exception
+            raise
+
     @staticmethod
     def create_id(cursor, model, query):
         """
@@ -150,7 +163,7 @@ class Source(relations_sql.SOURCE, relations.Source): # pylint: disable=too-many
         """
 
         query.generate()
-        cursor.execute(query.sql, tuple(query.args))
+        Source.write(cursor, model, query.sql, tuple(query.args))
 
         model[model._id] = cursor.lastrowid
 
@@ -170,7 +183,7 @@ class Source(relations_sql.SOURCE, relations.Source): # pylint: disable=too-many
         else:
             create_query = query or self.create_query(model)
             create_query.generate()
-            cursor.execute(create_query.sql, tuple(create_query.args))
+            self.write(cursor, model, create_query.sql, tuple(create_query.args))
 
         cursor.close()
 
@@ -391,14 +404,14 @@ class Source(relations_sql.SOURCE, relations.Source): # pylint: disable=too-many
         rows = cursor.fetchall()
 
         if model._mode == "one" and len(rows) > 1:
-            raise relations.ModelError(model, "more than one retrieved")
+            raise relations.MultipleError(model, "more than one retrieved")
 
         if model._mode == "one" and model._role != "child":
 
             if len(rows) < 1:
 
                 if verify:
-                    raise relations.ModelError(model, "none retrieved")
+                    raise relations.NotFoundError(model, "none retrieved")
                 return None
 
             model._record = model._build("update", _read=self.values_retrieve(model, dict(rows[0])))
@@ -494,7 +507,7 @@ class Source(relations_sql.SOURCE, relations.Source): # pylint: disable=too-many
             if update_query.SET.expressions:
 
                 update_query.generate()
-                cursor.execute(update_query.sql, update_query.args)
+                self.write(cursor, model, update_query.sql, update_query.args)
                 updated += cursor.rowcount
 
             ties = model._record.tie({})
@@ -524,7 +537,7 @@ class Source(relations_sql.SOURCE, relations.Source): # pylint: disable=too-many
                 if update_query.SET.expressions:
 
                     update_query.generate()
-                    cursor.execute(update_query.sql, update_query.args)
+                    self.write(cursor, updating, update_query.sql, update_query.args)
                     updated += cursor.rowcount
 
 

{relations_sqlite3-0.6.11 → relations_sqlite3-0.6.12}/setup.py

@@ -20,7 +20,7 @@ setup(
         'relations_sqlite3'
     ],
     install_requires=[
-        'relations-dil>=0.6.18',
+        'relations-dil>=0.6.19',
         'relations-sqlite>=0.6.4'
     ],
     url="https://github.com/relations-dil/python-relations-sqlite3",

{relations_sqlite3-0.6.11 → relations_sqlite3-0.6.12}/test/test_relations_sqlite3.py

@@ -262,6 +262,32 @@ CREATE UNIQUE INDEX `test_source`.`simple_name` ON `simple` (`name`);
         self.assertEqual(query.sql, """INSERT INTO `test_source`.`sis` (`name`) VALUES (?)""")
         self.assertEqual(query.args, ["sure"])
 
+    def test_write(self):
+
+        self.source.execute(Simple.define())
+
+        simple = Simple("sure")
+
+        cursor = self.source.connection.cursor()
+
+        # a write that works
+
+        self.source.write(cursor, simple, "INSERT INTO test_source.simple (name) VALUES (?)", ("one",))
+
+        # a duplicate is core's unique error, with the driver's error as its cause
+
+        with self.assertRaises(relations.UniqueError) as caught:
+            self.source.write(cursor, simple, "INSERT INTO test_source.simple (name) VALUES (?)", ("one",))
+
+        self.assertEqual(caught.exception.model, simple)
+        self.assertIsInstance(caught.exception.__cause__, sqlite3.IntegrityError)
+
+        # any other integrity error is left as it is
+
+        self.assertRaises(sqlite3.IntegrityError, self.source.write, cursor, simple, "INSERT INTO test_source.simple (name) VALUES (?)", (None,))
+
+        cursor.close()
+
     def test_create_id(self):
 
         self.source.execute(Simple.define())
@@ -279,6 +305,12 @@ CREATE UNIQUE INDEX `test_source`.`simple_name` ON `simple` (`name`);
         cursor.execute("SELECT * FROM test_source.simple")
         self.assertEqual(cursor.fetchone()["id"], simple.id)
 
+        # a duplicate is core's unique error
+
+        again = Simple("sure")
+
+        self.assertRaises(relations.UniqueError, self.source.create_id, cursor, again, self.source.create_query(again))
+
         cursor.close()
 
     def test_create(self):
@@ -365,6 +397,10 @@ CREATE UNIQUE INDEX `test_source`.`simple_name` ON `simple` (`name`);
             {"id": 2, "name": "stray", "what": {}}
         ])
 
+        # a duplicate is core's unique error
+
+        self.assertRaises(relations.UniqueError, Simple("sure").create)
+
     def test_retrieve_field(self):
 
         field = relations.Field(int, name="id")
@@ -564,10 +600,10 @@ CREATE UNIQUE INDEX `test_source`.`simple_name` ON `simple` (`name`);
         Unit([["stuff"], ["people"]]).create()
 
         models = Unit.one(name__in=["people", "stuff"])
-        self.assertRaisesRegex(relations.ModelError, "unit: more than one retrieved", models.retrieve)
+        self.assertRaisesRegex(relations.MultipleError, "unit: more than one retrieved", models.retrieve)
 
         model = Unit.one(name="things")
-        self.assertRaisesRegex(relations.ModelError, "unit: none retrieved", model.retrieve)
+        self.assertRaisesRegex(relations.NotFoundError, "unit: none retrieved", model.retrieve)
 
         self.assertIsNone(model.retrieve(False))
 
@@ -609,10 +645,10 @@ WHERE
         Unit([["stuff"], ["people"]]).create()
 
         models = Unit.one(name__in=["people", "stuff"])
-        self.assertRaisesRegex(relations.ModelError, "unit: more than one retrieved", models.retrieve)
+        self.assertRaisesRegex(relations.MultipleError, "unit: more than one retrieved", models.retrieve)
 
         model = Unit.one(name="things")
-        self.assertRaisesRegex(relations.ModelError, "unit: none retrieved", model.retrieve)
+        self.assertRaisesRegex(relations.NotFoundError, "unit: none retrieved", model.retrieve)
 
         self.assertIsNone(model.retrieve(False))
 
@@ -657,10 +693,10 @@ LIMIT ?""")
         Unit([["stuff"], ["people"]]).create()
 
         models = Unit.one(name__in=["people", "stuff"])
-        self.assertRaisesRegex(relations.ModelError, "unit: more than one retrieved", models.retrieve)
+        self.assertRaisesRegex(relations.MultipleError, "unit: more than one retrieved", models.retrieve)
 
         model = Unit.one(name="things")
-        self.assertRaisesRegex(relations.ModelError, "unit: none retrieved", model.retrieve)
+        self.assertRaisesRegex(relations.NotFoundError, "unit: none retrieved", model.retrieve)
 
         self.assertIsNone(model.retrieve(False))
 
@@ -789,10 +825,10 @@ LIMIT ?""")
         Unit([["stuff"], ["people"]]).create()
 
         models = Unit.one(name__in=["people", "stuff"])
-        self.assertRaisesRegex(relations.ModelError, "unit: more than one retrieved", models.retrieve)
+        self.assertRaisesRegex(relations.MultipleError, "unit: more than one retrieved", models.retrieve)
 
         model = Unit.one(name="things")
-        self.assertRaisesRegex(relations.ModelError, "unit: none retrieved", model.retrieve)
+        self.assertRaisesRegex(relations.NotFoundError, "unit: none retrieved", model.retrieve)
 
         self.assertIsNone(model.retrieve(False))
 
@@ -1303,6 +1339,18 @@ LIMIT ?""")
 
         self.assertRaisesRegex(relations.FieldError, "no mass update with inject", Pet.many(name="rex").set(owner_id=sam.id).update)
 
+        # a duplicate is core's unique error, for one record and for many
+
+        self.source.execute(Simple.define())
+        self.source.execute(Plain.define())
+
+        Simple("dup one").create()
+        two = Simple("dup two").create()
+
+        two.name = "dup one"
+        self.assertRaises(relations.UniqueError, two.update)
+        self.assertRaises(relations.UniqueError, Simple.many().set(name="same").update)
+
     def test_delete_query(self):
 
         self.source.execute(Unit.define())