Merge branch 'feature_add_bulk_document_update' of github.com:rostikts/core into rostikts-feature_add_bulk_document_update

dstpierre · dstpierre · commit bd9a9b96d0cb · 2022-08-16T03:37:26.000-04:00
diff --git a/database/memory/base.go b/database/memory/base.go
@@ -82,43 +82,7 @@ func (m *Memory) QueryDocuments(auth internal.Auth, dbName, col string, filter m
 
 	list = secureRead(auth, col, list)
 
-	var filtered []map[string]any
-	for _, doc := range list {
-		matches := 0
-		for k, v := range filter {
-			op, field := extractOperatorAndValue(k)
-			switch op {
-			case "=":
-				if equal(doc[field], v) {
-					matches++
-				}
-			case "!=":
-				if notEqual(doc[field], v) {
-					matches++
-				}
-			case ">":
-				if greater(doc[field], v) {
-					matches++
-				}
-			case "<":
-				if lower(doc[field], v) {
-					matches++
-				}
-			case ">=":
-				if greaterThanEqual(doc[field], v) {
-					matches++
-				}
-			case "<=":
-				if lowerThanEqual(doc[field], v) {
-					matches++
-				}
-			}
-		}
-
-		if matches == len(filter) {
-			filtered = append(filtered, doc)
-		}
-	}
+	filtered := filterByClauses(list, filter)
 
 	start := (params.Page - 1) * params.Size
 	end := start + params.Size - 1
@@ -156,9 +120,7 @@ func (m *Memory) UpdateDocument(auth internal.Auth, dbName, col, id string, doc
 		return
 	}
 
-	delete(doc, FieldID)
-	delete(doc, FieldAccountID)
-	delete(doc, FieldOwnerID)
+	removeNotEditableFields(doc)
 
 	for k, v := range doc {
 		exists[k] = v
@@ -168,6 +130,28 @@ func (m *Memory) UpdateDocument(auth internal.Auth, dbName, col, id string, doc
 	return
 }
 
+func (m *Memory) UpdateDocuments(auth internal.Auth, dbName, col string, filter map[string]interface{}, updateFields map[string]interface{}) (n int64, err error) {
+	list, err := all[map[string]any](m, dbName, col)
+
+	if err != nil {
+		return
+	}
+	list = secureRead(auth, col, list)
+
+	removeNotEditableFields(updateFields)
+	filtered := filterByClauses(list, filter)
+
+	for _, v := range filtered {
+		_, err := m.UpdateDocument(auth, dbName, col, v[FieldID].(string), updateFields)
+		if err != nil {
+			return n, err
+		}
+		n++
+	}
+
+	return
+}
+
 func (m *Memory) IncrementValue(auth internal.Auth, dbName, col, id, field string, n int) error {
 	doc, err := m.GetDocumentByID(auth, dbName, col, id)
 	if err != nil {
@@ -239,6 +223,12 @@ func extractOperatorAndValue(s string) (op string, field string) {
 	return
 }
 
+func removeNotEditableFields(m map[string]any) {
+	delete(m, FieldID)
+	delete(m, FieldAccountID)
+	delete(m, FieldOwnerID)
+}
+
 func equal(v any, val any) bool {
 	return fmt.Sprintf("%v", v) == fmt.Sprintf("%v", val)
 }
diff --git a/database/memory/base_test.go b/database/memory/base_test.go
@@ -208,6 +208,46 @@ func TestUpdateDocument(t *testing.T) {
 	}
 }
 
+func TestUpdateDocuments(t *testing.T) {
+	task1 := newTask("should be completed", false)
+	task2 := newTask("should be completed", false)
+
+	var many []interface{}
+	many = append(many, task1)
+	many = append(many, task2)
+
+	if err := datastore.BulkCreateDocument(adminAuth, confDBName, colName, many); err != nil {
+		t.Fatal(err)
+	}
+	var clauses [][]interface{}
+	clauses = append(clauses, []interface{}{"title", "=", "should be completed"})
+
+	filters, err := datastore.ParseQuery(clauses)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	updateFields := map[string]any{"done": true}
+	n, err := datastore.UpdateDocuments(adminAuth, confDBName, colName, filters, updateFields)
+	if err != nil {
+		t.Errorf("The documents are not updated because of an error\nExpected err = nil\nActual err: %s", err.Error())
+	}
+	if n != int64(len(many)) {
+		t.Errorf("The incorrect number of documents are updated\nExpected: %v\nActual: %v", len(many), n)
+	}
+
+	docs, err := datastore.QueryDocuments(adminAuth, confDBName, colName, filters, internal.ListParams{Page: 1, Size: 5})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, v := range docs.Results {
+		got := dec(v)
+		if !got.Done {
+			t.Errorf("The '%s' task is not updated; It should be completed (done=true)", got.Title)
+		}
+	}
+}
+
 func TestIncrementValue(t *testing.T) {
 	task1 := newTask("incr", false)
 	m, err := datastore.CreateDocument(adminAuth, confDBName, colName, task1)
diff --git a/database/memory/memory.go b/database/memory/memory.go
@@ -132,6 +132,46 @@ func filter[T any](list []T, fn func(x T) bool) []T {
 	return results
 }
 
+func filterByClauses(list []map[string]any, filter map[string]any) (filtered []map[string]any) {
+	for _, doc := range list {
+		matches := 0
+		for k, v := range filter {
+			op, field := extractOperatorAndValue(k)
+			switch op {
+			case "=":
+				if equal(doc[field], v) {
+					matches++
+				}
+			case "!=":
+				if notEqual(doc[field], v) {
+					matches++
+				}
+			case ">":
+				if greater(doc[field], v) {
+					matches++
+				}
+			case "<":
+				if lower(doc[field], v) {
+					matches++
+				}
+			case ">=":
+				if greaterThanEqual(doc[field], v) {
+					matches++
+				}
+			case "<=":
+				if lowerThanEqual(doc[field], v) {
+					matches++
+				}
+			}
+		}
+
+		if matches == len(filter) {
+			filtered = append(filtered, doc)
+		}
+	}
+	return
+}
+
 func sortSlice[T any](list []T, fn func(a, b T) bool) []T {
 	sort.Slice(list, func(i, j int) bool {
 		return fn(list[i], list[j])
diff --git a/database/mongo/base.go b/database/mongo/base.go
@@ -330,10 +330,7 @@ func (mg *Mongo) UpdateDocument(auth internal.Auth, dbName, col, id string, doc
 		return nil, err
 	}
 
-	delete(doc, "id")
-	delete(doc, FieldID)
-	delete(doc, FieldAccountID)
-	delete(doc, FieldOwnerID)
+	removeNotEditableFields(doc)
 
 	filter := bson.M{FieldID: oid}
 
@@ -366,6 +363,31 @@ func (mg *Mongo) UpdateDocument(auth internal.Auth, dbName, col, id string, doc
 	return result, nil
 }
 
+func (mg *Mongo) UpdateDocuments(auth internal.Auth, dbName, col string, filters map[string]interface{}, updateFields map[string]interface{}) (n int64, err error) {
+	db := mg.Client.Database(dbName)
+
+	acctID, userID, err := parseObjectID(auth)
+	if err != nil {
+		return 0, err
+	}
+
+	secureWrite(acctID, userID, auth.Role, col, filters)
+	removeNotEditableFields(updateFields)
+
+	newProps := bson.M{}
+	for k, v := range updateFields {
+		newProps[k] = v
+	}
+
+	update := bson.M{"$set": newProps}
+
+	res, err := db.Collection(internal.CleanCollectionName(col)).UpdateMany(mg.Ctx, filters, update)
+	if err != nil {
+		return 0, err
+	}
+	return res.ModifiedCount, err
+}
+
 func (mg *Mongo) IncrementValue(auth internal.Auth, dbName, col, id, field string, n int) error {
 	db := mg.Client.Database(dbName)
 
@@ -477,3 +499,10 @@ func cleanMap(m map[string]interface{}) {
 
 	delete(m, FieldOwnerID)
 }
+
+func removeNotEditableFields(m map[string]any) {
+	delete(m, "id")
+	delete(m, FieldID)
+	delete(m, FieldAccountID)
+	delete(m, FieldOwnerID)
+}
diff --git a/database/mongo/base_test.go b/database/mongo/base_test.go
@@ -208,6 +208,46 @@ func TestUpdateDocument(t *testing.T) {
 	}
 }
 
+func TestUpdateDocuments(t *testing.T) {
+	task1 := newTask("should be completed", false)
+	task2 := newTask("should be completed", false)
+
+	var many []interface{}
+	many = append(many, task1)
+	many = append(many, task2)
+
+	if err := datastore.BulkCreateDocument(adminAuth, confDBName, colName, many); err != nil {
+		t.Fatal(err)
+	}
+	var clauses [][]interface{}
+	clauses = append(clauses, []interface{}{"title", "=", "should be completed"})
+
+	filters, err := datastore.ParseQuery(clauses)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	updateFields := map[string]any{"done": true}
+	n, err := datastore.UpdateDocuments(adminAuth, confDBName, colName, filters, updateFields)
+	if err != nil {
+		t.Errorf("The documents are not updated because of an error\nExpected err = nil\nActual err: %s", err.Error())
+	}
+	if n != int64(len(many)) {
+		t.Errorf("The incorrect number of documents are updated\nExpected: %v\nActual: %v", len(many), n)
+	}
+
+	docs, err := datastore.QueryDocuments(adminAuth, confDBName, colName, filters, internal.ListParams{Page: 1, Size: 5})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, v := range docs.Results {
+		got := dec(v)
+		if !got.Done {
+			t.Errorf("The '%s' task is not updated; It should be completed (done=true)", got.Title)
+		}
+	}
+}
+
 func TestIncrementValue(t *testing.T) {
 	task1 := newTask("incr", false)
 	m, err := datastore.CreateDocument(adminAuth, confDBName, colName, task1)
diff --git a/database/postgresql/base.go b/database/postgresql/base.go
@@ -250,6 +250,31 @@ func (pg *PostgreSQL) UpdateDocument(auth internal.Auth, dbName, col, id string,
 	return updated, nil
 }
 
+func (pg *PostgreSQL) UpdateDocuments(auth internal.Auth, dbName, col string, filters map[string]interface{}, updateFields map[string]interface{}) (n int64, err error) {
+	where := secureWrite(auth, col)
+	where = applyFilter(where, filters)
+
+	qry := fmt.Sprintf(`
+		UPDATE %s.%s SET
+			data = data || $3
+		%s
+	`, dbName, internal.CleanCollectionName(col), where)
+
+	b, err := json.Marshal(updateFields)
+	if err != nil {
+		return 0, err
+	}
+	res, err := pg.DB.Exec(qry, auth.AccountID, auth.UserID, b)
+	if err != nil {
+		return 0, err
+	}
+	n, err = res.RowsAffected()
+	if err != nil {
+		return 0, err
+	}
+	return
+}
+
 func (pg *PostgreSQL) IncrementValue(auth internal.Auth, dbName, col, id, field string, n int) error {
 	where := secureWrite(auth, col)
 
diff --git a/database/postgresql/base_test.go b/database/postgresql/base_test.go
@@ -208,6 +208,46 @@ func TestUpdateDocument(t *testing.T) {
 	}
 }
 
+func TestUpdateDocuments(t *testing.T) {
+	task1 := newTask("should be completed", false)
+	task2 := newTask("should be completed", false)
+
+	var many []interface{}
+	many = append(many, task1)
+	many = append(many, task2)
+
+	if err := datastore.BulkCreateDocument(adminAuth, confDBName, colName, many); err != nil {
+		t.Fatal(err)
+	}
+	var clauses [][]interface{}
+	clauses = append(clauses, []interface{}{"title", "=", "should be completed"})
+
+	filters, err := datastore.ParseQuery(clauses)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	updateFields := map[string]any{"done": true}
+	n, err := datastore.UpdateDocuments(adminAuth, confDBName, colName, filters, updateFields)
+	if err != nil {
+		t.Errorf("The documents are not updated because of an error\nExpected err = nil\nActual err: %s", err.Error())
+	}
+	if n != int64(len(many)) {
+		t.Errorf("The incorrect number of documents are updated\nExpected: %v\nActual: %v", len(many), n)
+	}
+
+	docs, err := datastore.QueryDocuments(adminAuth, confDBName, colName, filters, internal.ListParams{Page: 1, Size: 5})
+	if err != nil {
+		t.Fatal(err)
+	}
+	for _, v := range docs.Results {
+		got := dec(v)
+		if !got.Done {
+			t.Errorf("The '%s' task is not updated; It should be completed (done=true)", got.Title)
+		}
+	}
+}
+
 func TestIncrementValue(t *testing.T) {
 	task1 := newTask("incr", false)
 	m, err := datastore.CreateDocument(adminAuth, confDBName, colName, task1)
diff --git a/db.go b/db.go
diff --git a/db_test.go b/db_test.go
diff --git a/internal/persister.go b/internal/persister.go
