optimize code to use a dynamic array of strings instead of map

src/storage/mysql-storage.go

@@ -245,35 +245,21 @@ func (dbobj MySQLDB) decodeFieldsValues(data interface{}) (string, []interface{}
 	return fields, values
 }
 
-func (dbobj MySQLDB) decodeForCleanup(data interface{}) string {
+func (dbobj MySQLDB) decodeForCleanup(bdel []string) string {
 	fields := ""
-
-	switch t := data.(type) {
-	case primitive.M:
-		for idx := range data.(primitive.M) {
-			if len(fields) == 0 {
-				fields = dbobj.escapeName(idx) + "=null"
-			} else {
-				fields = fields + "," + dbobj.escapeName(idx) + "=null"
-			}
-		}
-		return fields
-	case map[string]interface{}:
-		for idx := range data.(map[string]interface{}) {
-			if len(fields) == 0 {
-				fields = dbobj.escapeName(idx) + "=null"
-			} else {
-				fields = fields + "," + dbobj.escapeName(idx) + "=null"
-			}
-		}
-	default:
-		fmt.Printf("decodeForCleanup: wrong type: %s\n", t)
-	}
-
+        if bdel != nil {
+                for _, colname := range bdel {
+                        if len(fields) == 0 {
+                                fields = dbobj.escapeName(colname) + "=null"
+                        } else {
+                                fields = fields + "," + dbobj.escapeName(colname) + "=null"
+                        }
+                }
+        }
 	return fields
 }
 
-func (dbobj MySQLDB) decodeForUpdate(bdoc *bson.M, bdel *bson.M) (string, []interface{}) {
+func (dbobj MySQLDB) decodeForUpdate(bdoc *bson.M, bdel []string) (string, []interface{}) {
 	values := make([]interface{}, 0)
 	fields := ""
 
@@ -295,15 +281,15 @@ func (dbobj MySQLDB) decodeForUpdate(bdoc *bson.M, bdel *bson.M) (string, []inte
 		}
 	}
 
-	if bdel != nil {
-		for idx := range *bdel {
-			if len(fields) == 0 {
-				fields = dbobj.escapeName(idx) + "=null"
-			} else {
-				fields = fields + "," + dbobj.escapeName(idx) + "=null"
-			}
-		}
-	}
+        if bdel != nil {
+                for _, colname := range bdel {
+                        if len(fields) == 0 {
+                                fields = dbobj.escapeName(colname) + "=null"
+                        } else {
+                                fields = fields + "," + dbobj.escapeName(colname) + "=null"
+                        }
+                }
+        }
 	return fields, values
 }
 
@@ -408,7 +394,7 @@ func (dbobj MySQLDB) UpdateRecordInTable(table string, keyName string, keyValue
 
 // UpdateRecord2 updates database record
 func (dbobj MySQLDB) UpdateRecord2(t Tbl, keyName string, keyValue string,
-	keyName2 string, keyValue2 string, bdoc *bson.M, bdel *bson.M) (int64, error) {
+	keyName2 string, keyValue2 string, bdoc *bson.M, bdel []string) (int64, error) {
 	table := GetTable(t)
 	filter := dbobj.escapeName(keyName) + "=\"" + keyValue + "\" AND " +
 		dbobj.escapeName(keyName2) + "=\"" + keyValue2 + "\""
@@ -417,13 +403,13 @@ func (dbobj MySQLDB) UpdateRecord2(t Tbl, keyName string, keyValue string,
 
 // UpdateRecordInTable2 updates database record
 func (dbobj MySQLDB) UpdateRecordInTable2(table string, keyName string,
-	keyValue string, keyName2 string, keyValue2 string, bdoc *bson.M, bdel *bson.M) (int64, error) {
+	keyValue string, keyName2 string, keyValue2 string, bdoc *bson.M, bdel []string) (int64, error) {
 	filter := dbobj.escapeName(keyName) + "=\"" + keyValue + "\" AND " +
 		dbobj.escapeName(keyName2) + "=\"" + keyValue2 + "\""
 	return dbobj.updateRecordInTableDo(table, filter, bdoc, bdel)
 }
 
-func (dbobj MySQLDB) updateRecordInTableDo(table string, filter string, bdoc *bson.M, bdel *bson.M) (int64, error) {
+func (dbobj MySQLDB) updateRecordInTableDo(table string, filter string, bdoc *bson.M, bdel []string) (int64, error) {
 	op, values := dbobj.decodeForUpdate(bdoc, bdel)
 	q := "update " + table + " SET " + op + " WHERE " + filter
 	//fmt.Printf("q: %s\n", q)
@@ -708,9 +694,9 @@ func (dbobj MySQLDB) DeleteExpired(t Tbl, keyName string, keyValue string) (int6
 }
 
 // CleanupRecord nullifies specific feilds in records in database
-func (dbobj MySQLDB) CleanupRecord(t Tbl, keyName string, keyValue string, data interface{}) (int64, error) {
+func (dbobj MySQLDB) CleanupRecord(t Tbl, keyName string, keyValue string, bdel []string) (int64, error) {
 	tbl := GetTable(t)
-	cleanup := dbobj.decodeForCleanup(data)
+	cleanup := dbobj.decodeForCleanup(bdel)
 	q := "update " + tbl + " SET " + cleanup + " WHERE " + dbobj.escapeName(keyName) + "=?"
 	fmt.Printf("q: %s\n", q)
 

src/storage/pgsql-storage.go

@@ -243,35 +243,21 @@ func (dbobj PGSQLDB) decodeFieldsValues(data interface{}) (string, []interface{}
 	return fields, values
 }
 
-func (dbobj PGSQLDB) decodeForCleanup(data interface{}) string {
-	fields := ""
-
-	switch t := data.(type) {
-	case primitive.M:
-		for idx := range data.(primitive.M) {
-			if len(fields) == 0 {
-				fields = dbobj.escapeName(idx) + "=null"
-			} else {
-				fields = fields + "," + dbobj.escapeName(idx) + "=null"
-			}
-		}
-		return fields
-	case map[string]interface{}:
-		for idx := range data.(map[string]interface{}) {
-			if len(fields) == 0 {
-				fields = dbobj.escapeName(idx) + "=null"
-			} else {
-				fields = fields + "," + dbobj.escapeName(idx) + "=null"
-			}
-		}
-	default:
-		fmt.Printf("decodeForCleanup: wrong type: %s\n", t)
-	}
-
-	return fields
+func (dbobj PGSQLDB) decodeForCleanup(bdel []string) string {
+        fields := ""
+        if bdel != nil {
+                for _, colname := range bdel {
+                        if len(fields) == 0 {
+                                fields = dbobj.escapeName(colname) + "=null"
+                        } else {
+                                fields = fields + "," + dbobj.escapeName(colname) + "=null"
+                        }
+                }
+        }
+        return fields
 }
 
-func (dbobj PGSQLDB) decodeForUpdate(bdoc *bson.M, bdel *bson.M) (string, []interface{}) {
+func (dbobj PGSQLDB) decodeForUpdate(bdoc *bson.M, bdel []string) (string, []interface{}) {
 	values := make([]interface{}, 0)
 	fields := ""
 
@@ -294,11 +280,11 @@ func (dbobj PGSQLDB) decodeForUpdate(bdoc *bson.M, bdel *bson.M) (string, []inte
 	}
 
 	if bdel != nil {
-		for idx := range *bdel {
+		for _, colname := range bdel {
 			if len(fields) == 0 {
-				fields = dbobj.escapeName(idx) + "=null"
+				fields = dbobj.escapeName(colname) + "=null"
 			} else {
-				fields = fields + "," + dbobj.escapeName(idx) + "=null"
+				fields = fields + "," + dbobj.escapeName(colname) + "=null"
 			}
 		}
 	}
@@ -406,7 +392,7 @@ func (dbobj PGSQLDB) UpdateRecordInTable(table string, keyName string, keyValue
 
 // UpdateRecord2 updates database record
 func (dbobj PGSQLDB) UpdateRecord2(t Tbl, keyName string, keyValue string,
-	keyName2 string, keyValue2 string, bdoc *bson.M, bdel *bson.M) (int64, error) {
+	keyName2 string, keyValue2 string, bdoc *bson.M, bdel []string) (int64, error) {
 	table := GetTable(t)
 	filter := dbobj.escapeName(keyName) + "='" + keyValue + "' AND " +
 		dbobj.escapeName(keyName2) + "='" + keyValue2 + "'"
@@ -415,13 +401,13 @@ func (dbobj PGSQLDB) UpdateRecord2(t Tbl, keyName string, keyValue string,
 
 // UpdateRecordInTable2 updates database record
 func (dbobj PGSQLDB) UpdateRecordInTable2(table string, keyName string,
-	keyValue string, keyName2 string, keyValue2 string, bdoc *bson.M, bdel *bson.M) (int64, error) {
+	keyValue string, keyName2 string, keyValue2 string, bdoc *bson.M, bdel []string) (int64, error) {
 	filter := dbobj.escapeName(keyName) + "='" + keyValue + "' AND " +
 		dbobj.escapeName(keyName2) + "='" + keyValue2 + "'"
 	return dbobj.updateRecordInTableDo(table, filter, bdoc, bdel)
 }
 
-func (dbobj PGSQLDB) updateRecordInTableDo(table string, filter string, bdoc *bson.M, bdel *bson.M) (int64, error) {
+func (dbobj PGSQLDB) updateRecordInTableDo(table string, filter string, bdoc *bson.M, bdel []string) (int64, error) {
 	op, values := dbobj.decodeForUpdate(bdoc, bdel)
 	q := "update " + table + " SET " + op + " WHERE " + filter
 	//fmt.Printf("q: %s\n", q)
@@ -706,9 +692,9 @@ func (dbobj PGSQLDB) DeleteExpired(t Tbl, keyName string, keyValue string) (int6
 }
 
 // CleanupRecord nullifies specific feilds in records in database
-func (dbobj PGSQLDB) CleanupRecord(t Tbl, keyName string, keyValue string, data interface{}) (int64, error) {
+func (dbobj PGSQLDB) CleanupRecord(t Tbl, keyName string, keyValue string, bdel []string) (int64, error) {
 	tbl := GetTable(t)
-	cleanup := dbobj.decodeForCleanup(data)
+	cleanup := dbobj.decodeForCleanup(bdel)
 	q := "update " + tbl + " SET " + cleanup + " WHERE " + dbobj.escapeName(keyName) + "=$1"
 	fmt.Printf("q: %s\n", q)
 

src/storage/sqlite-storage.go

@@ -233,35 +233,21 @@ func (dbobj SQLiteDB) decodeFieldsValues(data interface{}) (string, []interface{
 	return fields, values
 }
 
-func (dbobj SQLiteDB) decodeForCleanup(data interface{}) string {
-	fields := ""
-
-	switch t := data.(type) {
-	case primitive.M:
-		for idx := range data.(primitive.M) {
-			if len(fields) == 0 {
-				fields = dbobj.escapeName(idx) + "=null"
-			} else {
-				fields = fields + "," + dbobj.escapeName(idx) + "=null"
-			}
-		}
-		return fields
-	case map[string]interface{}:
-		for idx := range data.(map[string]interface{}) {
-			if len(fields) == 0 {
-				fields = dbobj.escapeName(idx) + "=null"
-			} else {
-				fields = fields + "," + dbobj.escapeName(idx) + "=null"
-			}
-		}
-	default:
-		log.Printf("decodeForCleanup: wrong type: %s\n", t)
-	}
-
-	return fields
+func (dbobj SQLiteDB) decodeForCleanup(bdel []string) string {
+        fields := ""
+        if bdel != nil {
+                for _, colname := range bdel {
+                        if len(fields) == 0 {
+                                fields = dbobj.escapeName(colname) + "=null"
+                        } else {
+                                fields = fields + "," + dbobj.escapeName(colname) + "=null"
+                        }
+                }
+        }
+        return fields
 }
 
-func (dbobj SQLiteDB) decodeForUpdate(bdoc *bson.M, bdel *bson.M) (string, []interface{}) {
+func (dbobj SQLiteDB) decodeForUpdate(bdoc *bson.M, bdel []string) (string, []interface{}) {
 	values := make([]interface{}, 0)
 	fields := ""
 
@@ -283,15 +269,15 @@ func (dbobj SQLiteDB) decodeForUpdate(bdoc *bson.M, bdel *bson.M) (string, []int
 		}
 	}
 
-	if bdel != nil {
-		for idx := range *bdel {
-			if len(fields) == 0 {
-				fields = dbobj.escapeName(idx) + "=null"
-			} else {
-				fields = fields + "," + dbobj.escapeName(idx) + "=null"
-			}
-		}
-	}
+        if bdel != nil {
+                for _, colname := range bdel {
+                        if len(fields) == 0 {
+                                fields = dbobj.escapeName(colname) + "=null"
+                        } else {
+                                fields = fields + "," + dbobj.escapeName(colname) + "=null"
+                        }
+                }
+        }
 	return fields, values
 }
 
@@ -397,7 +383,7 @@ func (dbobj SQLiteDB) UpdateRecordInTable(table string, keyName string, keyValue
 
 // UpdateRecord2 updates database record
 func (dbobj SQLiteDB) UpdateRecord2(t Tbl, keyName string, keyValue string,
-	keyName2 string, keyValue2 string, bdoc *bson.M, bdel *bson.M) (int64, error) {
+	keyName2 string, keyValue2 string, bdoc *bson.M, bdel []string) (int64, error) {
 	table := GetTable(t)
 	filter := dbobj.escapeName(keyName) + "=\"" + keyValue + "\" AND " +
 		dbobj.escapeName(keyName2) + "=\"" + keyValue2 + "\""
@@ -406,13 +392,13 @@ func (dbobj SQLiteDB) UpdateRecord2(t Tbl, keyName string, keyValue string,
 
 // UpdateRecordInTable2 updates database record
 func (dbobj SQLiteDB) UpdateRecordInTable2(table string, keyName string,
-	keyValue string, keyName2 string, keyValue2 string, bdoc *bson.M, bdel *bson.M) (int64, error) {
+	keyValue string, keyName2 string, keyValue2 string, bdoc *bson.M, bdel []string) (int64, error) {
 	filter := dbobj.escapeName(keyName) + "=\"" + keyValue + "\" AND " +
 		dbobj.escapeName(keyName2) + "=\"" + keyValue2 + "\""
 	return dbobj.updateRecordInTableDo(table, filter, bdoc, bdel)
 }
 
-func (dbobj SQLiteDB) updateRecordInTableDo(table string, filter string, bdoc *bson.M, bdel *bson.M) (int64, error) {
+func (dbobj SQLiteDB) updateRecordInTableDo(table string, filter string, bdoc *bson.M, bdel []string) (int64, error) {
 	op, values := dbobj.decodeForUpdate(bdoc, bdel)
 	q := "update " + table + " SET " + op + " WHERE " + filter
 	//fmt.Printf("q: %s\n", q)
@@ -690,11 +676,11 @@ func (dbobj SQLiteDB) DeleteExpired(t Tbl, keyName string, keyValue string) (int
 }
 
 // CleanupRecord nullifies specific feilds in records in database
-func (dbobj SQLiteDB) CleanupRecord(t Tbl, keyName string, keyValue string, data interface{}) (int64, error) {
+func (dbobj SQLiteDB) CleanupRecord(t Tbl, keyName string, keyValue string, bdel []string) (int64, error) {
 	tbl := GetTable(t)
-	cleanup := dbobj.decodeForCleanup(data)
+	cleanup := dbobj.decodeForCleanup(bdel)
 	q := "update " + tbl + " SET " + cleanup + " WHERE " + dbobj.escapeName(keyName) + "=$1"
-	log.Printf("q: %s\n", q)
+	log.Printf("CleanupRecord q: %s\n", q)
 
 	tx, err := dbobj.db.Begin()
 	if err != nil {

src/storage/storage.go

@@ -83,8 +83,8 @@ type BackendDB interface {
 	CountRecords(Tbl, string, string) (int64, error)
 	UpdateRecord(Tbl, string, string, *bson.M) (int64, error)
 	UpdateRecordInTable(string, string, string, *bson.M) (int64, error)
-	UpdateRecord2(Tbl, string, string, string, string, *bson.M, *bson.M) (int64, error)
-	UpdateRecordInTable2(string, string, string, string, string, *bson.M, *bson.M) (int64, error)
+	UpdateRecord2(Tbl, string, string, string, string, *bson.M, []string) (int64, error)
+	UpdateRecordInTable2(string, string, string, string, string, *bson.M, []string) (int64, error)
 	LookupRecord(Tbl, bson.M) (bson.M, error)
 	GetRecord(Tbl, string, string) (bson.M, error)
 	GetRecordFromTable(string, string, string) (bson.M, error)
@@ -94,7 +94,7 @@ type BackendDB interface {
 	DeleteRecord2(Tbl, string, string, string, string) (int64, error)
 	DeleteExpired0(Tbl, int32) (int64, error)
 	DeleteExpired(Tbl, string, string) (int64, error)
-	CleanupRecord(Tbl, string, string, interface{}) (int64, error)
+	CleanupRecord(Tbl, string, string, []string) (int64, error)
 	GetExpiring(Tbl, string, string) ([]bson.M, error)
 	GetUniqueList(Tbl, string) ([]bson.M, error)
 	GetList0(Tbl, int32, int32, string) ([]bson.M, error)

src/users_db.go

@@ -209,7 +209,7 @@ func (dbobj dbcon) updateUserRecordDo(jsonDataPatch []byte, userTOKEN string, ol
 	if err != nil {
 		return nil, nil, false, err
 	}
-	bdel := bson.M{}
+	var bdel []string
 	sig := oldUserBson["md5"].(string)
 	// create new user record
 	bdoc := bson.M{}
@@ -256,7 +256,7 @@ func (dbobj dbcon) updateUserRecordDo(jsonDataPatch []byte, userTOKEN string, ol
 			//fmt.Printf("adding index3? %s\n", raw[idx])
 			bdoc[idx+"idx"] = hashString(dbobj.hash, newIdxFinalValue)
 		} else if len(newIdxFinalValue) == 0 {
-			bdel[idx+"idx"] = ""
+			bdel = append(bdel, idx+"idx")
 		}
 	}
 
@@ -274,7 +274,7 @@ func (dbobj dbcon) updateUserRecordDo(jsonDataPatch []byte, userTOKEN string, ol
 	//filter2 := bson.D{{"token", userTOKEN}, {"md5", sig}}
 
 	//fmt.Printf("op json: %s\n", update)
-	result, err := dbobj.store.UpdateRecord2(storage.TblName.Users, "token", userTOKEN, "md5", sig, &bdoc, &bdel)
+	result, err := dbobj.store.UpdateRecord2(storage.TblName.Users, "token", userTOKEN, "md5", sig, &bdoc, bdel)
 	if err != nil {
 		return nil, nil, false, err
 	}
@@ -517,7 +517,7 @@ func (dbobj dbcon) deleteUserRecord(userJSON []byte, userTOKEN string, conf Conf
 	dbobj.store.DeleteRecord(storage.TblName.Sessions, "token", userTOKEN)
 
 	dataJSON, record := cleanupRecord(userJSON)
-	bdel := bson.M{}
+	var bdel []string
 	if dataJSON != nil {
 		oldUserBson, err := dbobj.lookupUserRecord(userTOKEN)
 		if err != nil {
@@ -535,19 +535,19 @@ func (dbobj dbcon) deleteUserRecord(userJSON []byte, userTOKEN string, conf Conf
 			fmt.Printf("Preservice email idx\n")
 			bdoc["emailidx"] = oldUserBson["emailidx"].(string)
 		} else {
-			bdel["emailidx"] = ""
+			bdel = append(bdel, "emailidx")
 		}
 		if _, ok := record["phone"]; ok {
 			fmt.Printf("Preservice phone idx\n")
 			bdoc["phoneidx"] = oldUserBson["phoneidx"].(string)
 		} else {
-			bdel["phoneidx"] = ""
+			bdel = append(bdel, "phoneidx")
 		}
 		if _, ok := record["login"]; ok {
 			fmt.Printf("Preservice login idx\n")
 			bdoc["loginidx"] = oldUserBson["loginidx"].(string)
 		} else {
-			bdel["loginidx"] = ""
+			bdel = append(bdel, "loginidx")
 		}
 		encoded, _ := encrypt(dbobj.masterKey, userKeyBinary, dataJSON)
 		encodedStr := base64.StdEncoding.EncodeToString(encoded)
@@ -556,7 +556,7 @@ func (dbobj dbcon) deleteUserRecord(userJSON []byte, userTOKEN string, conf Conf
 		md5Hash := md5.Sum([]byte(encodedStr))
 		bdoc["md5"] = base64.StdEncoding.EncodeToString(md5Hash[:])
 		bdoc["token"] = userTOKEN
-		result, err := dbobj.store.UpdateRecord2(storage.TblName.Users, "token", userTOKEN, "md5", sig, &bdoc, &bdel)
+		result, err := dbobj.store.UpdateRecord2(storage.TblName.Users, "token", userTOKEN, "md5", sig, &bdoc, bdel)
 		if err != nil {
 			return false, err
 		}
@@ -566,12 +566,7 @@ func (dbobj dbcon) deleteUserRecord(userJSON []byte, userTOKEN string, conf Conf
 		return false, nil
 	}
 	// cleanup user record
-	bdel["data"] = ""
-	bdel["key"] = ""
-	bdel["loginidx"] = ""
-	bdel["emailidx"] = ""
-	bdel["phoneidx"] = ""
-	bdel["customidx"] = ""
+	bdel = append(bdel, "data", "key", "loginidx", "emailidx", "phoneidx", "customidx")
 	result, err := dbobj.store.CleanupRecord(storage.TblName.Users, "token", userTOKEN, bdel)
 	if err != nil {
 		return false, err