Added tests, docs, cleanup for adding fields parameter/Django 2.2 support.

Author: ses4j

README.md

@@ -1,13 +1,14 @@
 # django-bulk-sync
+
 Combine bulk create, update, and delete into a single call.
 
-`django-bulk-sync` is a package for the Django ORM that combines bulk_create, bulk_update, and delete into a single method call to `bulk_sync`.  
+`django-bulk-sync` is a package for the Django ORM that combines bulk_create, bulk_update, and delete into a single method call to `bulk_sync`.
 
 It manages all necessary creates, updates, and deletes with as few database calls as possible to maximize performance.
 
 ## Installation
 
-The package is available on pip as [django-bulk-sync][django-bulk-sync].  Run:
+The package is available on pip as [django-bulk-sync][django-bulk-sync]. Run:
 
 `pip install django-bulk-sync`
 
@@ -17,17 +18,17 @@ then import via:
 
 ## A Usage Scenario
 
-Companies have zero or more Employees. You want to efficiently sync the names of all employees for a single `Company` from an import from that company, but some are added, updated, or removed.  The simple approach is inefficient -- read the import line by line, and:
+Companies have zero or more Employees. You want to efficiently sync the names of all employees for a single `Company` from an import from that company, but some are added, updated, or removed. The simple approach is inefficient -- read the import line by line, and:
 
 For each of N records:
 
-- SELECT to check for the employee's existence
-- UPDATE if it exists, INSERT if it doesn't
+-   SELECT to check for the employee's existence
+-   UPDATE if it exists, INSERT if it doesn't
+
+Then figure out some way to identify what was missing and delete it. As is so often the case, the speed of this process is controlled mostly by the number of queries run, and here it is about two queries for every record, and so O(N).
 
-Then figure out some way to identify what was missing and delete it.  As is so often the case, the speed of this process is controlled mostly by the number of queries run, and here it is about two queries for every record, and so O(N).
+Instead, with `bulk_sync`, we can avoid the O(N) number of queries, and simplify the logic we have to write as well.
 
-Instead, with `bulk_sync`, we can avoid the O(N) number of queries, and simplify the logic we have to write as well. 
-	
 ## Example Usage
 
 ```python
@@ -36,16 +37,16 @@ from bulk_sync import bulk_sync
 
 new_models = []
 for line in company_import_file:
-	# The `.id` (or `.pk`) field should not be set. Instead, `key_fields` 
+	# The `.id` (or `.pk`) field should not be set. Instead, `key_fields`
 	# tells it how to match.
 	e = Employee(name=line['name'], phone_number=line['phone_number'], ...)
 	new_models.append(e)
 
-# `filters` controls the subset of objects considered when deciding to 
+# `filters` controls the subset of objects considered when deciding to
 # update or delete.
-filters = Q(company_id=501)  
+filters = Q(company_id=501)
 # `key_fields` matches an existing object if all `key_fields` are equal.
-key_fields = ('name', )  
+key_fields = ('name', )
 ret = bulk_sync(
         new_models=new_models,
         filters=filters,
@@ -57,34 +58,39 @@ print("Results of bulk_sync: "
       		.format(**ret['stats']))
 ```
 
-Under the hood, it will atomically call `bulk_create`, `bulk_update`, and a single queryset `delete()` call, to correctly and efficiently update all fields of all employees for the filtered Company, using `name` to match properly. 
+Under the hood, it will atomically call `bulk_create`, `bulk_update`, and a single queryset `delete()` call, to correctly and efficiently update all fields of all employees for the filtered Company, using `name` to match properly.
 
 ## Argument Reference
 
-`def bulk_sync(new_models, key_fields, filters, batch_size=None):`
-Combine bulk create, update, and delete.  Make the DB match a set of in-memory objects.
-- `new_models`: An iterable of Django ORM `Model` objects that you want stored in the database. They may or may not have `id` set, but you should not have already called `save()` on them.
-- `key_fields`: Identifying attribute name(s) to match up `new_models` items with database rows.  If a foreign key is being used as a key field, be sure to pass the `fieldname_id` rather than the `fieldname`.
-- `filters`: Q() filters specifying the subset of the database to work in.
-- `batch_size`: passes through to Django `bulk_create.batch_size` and `bulk_update.batch_size`, and controls how many objects are created/updated per SQL query.
-- `fields`: a list of fields to update - passed through to Django's built in `buld_update` 
+`def bulk_sync(new_models, key_fields, filters, batch_size=None, fields=None):`
+Combine bulk create, update, and delete. Make the DB match a set of in-memory objects.
+
+-   `new_models`: An iterable of Django ORM `Model` objects that you want stored in the database. They may or may not have `id` set, but you should not have already called `save()` on them.
+-   `key_fields`: Identifying attribute name(s) to match up `new_models` items with database rows. If a foreign key is being used as a key field, be sure to pass the `fieldname_id` rather than the `fieldname`.
+-   `filters`: Q() filters specifying the subset of the database to work in. Use `None` or `[]` if you want to sync against the entire table.
+-   `batch_size`: passes through to Django `bulk_create.batch_size` and `bulk_update.batch_size`, and controls how many objects are created/updated per SQL query.
+-   `fields`: (optional) List of fields to update. If not set, will sync all fields that are editable and not auto-created.
+-   Returns a dict:
+
+    {
+    'stats': {
+    "created": number of `new_models` not found in database and so created,
+    "updated": number of `new_models` that were found in database as matched by `key_fields`,
+    "deleted": number of deleted objects - rows in database that matched `filters` but were not present in `new_models`.
+    }
+    }
 
 `def bulk_compare(old_models, new_models, key_fields, ignore_fields=None):`
 Compare two sets of models by `key_fields`.
-- `old_models`: Iterable of Django ORM objects to compare.
-- `new_models`: Iterable of Django ORM objects to compare.
-- `key_fields`: Identifying attribute name(s) to match up `new_models` items with database rows.  If a foreign key
-        is being used as a key field, be sure to pass the `fieldname_id` rather than the `fieldname`.
-- `ignore_fields`: (optional) If set, provide field names that should not be considered when comparing objects.
-- Returns dict of: ```
-    {
-        'added': list of all added objects.
-        'unchanged': list of all unchanged objects.
-        'updated': list of all updated objects.
-        'updated_details': dict of {obj: {field_name: (old_value, new_value)}} for all changed fields in each updated object.
-        'removed': list of all removed objects.
-    } ```
+
+-   `old_models`: Iterable of Django ORM objects to compare.
+-   `new_models`: Iterable of Django ORM objects to compare.
+-   `key_fields`: Identifying attribute name(s) to match up `new_models` items with database rows. If a foreign key
+    is being used as a key field, be sure to pass the `fieldname_id` rather than the `fieldname`.
+-   `ignore_fields`: (optional) If set, provide field names that should not be considered when comparing objects.
+-   Returns dict of: `{ 'added': list of all added objects. 'unchanged': list of all unchanged objects. 'updated': list of all updated objects. 'updated_details': dict of {obj: {field_name: (old_value, new_value)}} for all changed fields in each updated object. 'removed': list of all removed objects. }`
 
 ## Frameworks Supported
 
-This library is tested using Python 3 against Django 2.2.
+This library is tested using Python 3 against Django 2.2+. If you are looking for versions that work with Django < 2.2,
+please use the 1.x releases.

bulk_sync/__init__.py

@@ -12,15 +12,15 @@ def bulk_sync(new_models, key_fields, filters, batch_size=None, fields=None):
     `new_models`: Django ORM objects that are the desired state.  They may or may not have `id` set.
     `key_fields`: Identifying attribute name(s) to match up `new_models` items with database rows.  If a foreign key
             is being used as a key field, be sure to pass the `fieldname_id` rather than the `fieldname`.
-    `filters`: Q() filters specifying the subset of the database to work in.
+    `filters`: Q() filters specifying the subset of the database to work in.  Use `None` or `[]` if you want to sync against the entire table.
     `batch_size`: passes through to Django `bulk_create.batch_size` and `bulk_update.batch_size`, and controls
             how many objects are created/updated per SQL query.
-    `fields`: a list of fields to update - passed to django's bulk_update
+    `fields`: (optional) list of fields to update. If not set, will sync all fields that are editable and not auto-created.
 
     """
     db_class = new_models[0].__class__
 
-    if not fields:
+    if fields is None:
         # Get a list of fields that aren't PKs and aren't editable (e.g. auto_add_now) for bulk_update
         fields = [field.name
                   for field in db_class._meta.fields

setup.py

@@ -5,7 +5,7 @@
 
 setuptools.setup(
     name="django-bulk-sync",
-    version='1.3.1',
+    version='2.0.0',
     description="Combine bulk add, update, and delete into a single call.",
     long_description=long_description,
     long_description_content_type='text/markdown',
@@ -18,7 +18,6 @@
         'License :: OSI Approved :: MIT License',
         'Operating System :: OS Independent',
         'Framework :: Django',
-        'Framework :: Django :: 1.11',
         'Framework :: Django :: 2.2',
     ],
     zip_safe=False,

tests/tests.py

@@ -75,6 +75,34 @@ def test_pk_set_but_keyfield_changes_ignores_pk(self):
 
         ret = bulk_sync(new_models=new_objs, filters=Q(company_id=c1.id), key_fields=("name",))
 
+    def test_fields_parameter(self):
+        c1 = Company.objects.create(name="Foo Products, Ltd.")
+        c2 = Company.objects.create(name="Bar Microcontrollers, Inc.")
+
+        e1 = Employee.objects.create(name="Scott", age=40, company=c1)
+        e2 = Employee.objects.create(name="Isaac", age=9, company=c2)
+
+        # We should update Scott's age, and not touch company.
+        new_objs = [
+            Employee(name="Scott", age=41, company=c1),
+            Employee(name="Isaac", age=9, company=c1),
+        ]
+
+        ret = bulk_sync(new_models=new_objs, filters=None, key_fields=("name",), fields=['age'])
+
+        new_e1 = Employee.objects.get(id=e1.id)
+        self.assertEqual("Scott", new_e1.name)
+        self.assertEqual(41, new_e1.age)
+        self.assertEqual(c1, new_e1.company)
+
+        new_e2 = Employee.objects.get(id=e2.id)
+        self.assertEqual("Isaac", new_e2.name)
+        self.assertEqual(9, new_e2.age)
+        self.assertEqual(c2, new_e2.company)
+
+        self.assertEqual(2, ret["stats"]["updated"])
+        self.assertEqual(0, ret["stats"]["created"])
+        self.assertEqual(0, ret["stats"]["deleted"])
 
 class BulkCompareTests(TestCase):
     """ Test `bulk_compare` method """