diff --git a/cmd/cgr-tester/cgr-tester.go b/cmd/cgr-tester/cgr-tester.go
index 34746c47e..9cff7f06b 100644
--- a/cmd/cgr-tester/cgr-tester.go
+++ b/cmd/cgr-tester/cgr-tester.go
@@ -91,7 +91,7 @@ func durInternalRater(cd *engine.CallDescriptorWithAPIOpts) (time.Duration, erro
 	dm := engine.NewDataManager(dbConn, cgrConfig.CacheCfg(), nil) // for the momentn we use here "" for sentinelName
 	defer dm.DataDB().Close()
 	engine.SetDataStorage(dm)
-	if err := dm.LoadDataDBCache(engine.GetDefaultEmptyArgCachePrefix()); err != nil {
+	if err := engine.LoadAllDataDBToCache(dm); err != nil {
 		return nilDuration, fmt.Errorf("Cache rating error: %s", err.Error())
 	}
 	log.Printf("Runnning %d cycles...", *runs)
diff --git a/engine/account.go b/engine/account.go
index bb7c2c665..dc8a1fed8 100644
--- a/engine/account.go
+++ b/engine/account.go
@@ -248,7 +248,7 @@ func (acc *Account) debitBalanceAction(a *Action, reset, resetIfNegative bool) e
 		}
 		acc.BalanceMap[balanceType] = append(acc.BalanceMap[balanceType], bClone)
 		_, err := guardian.Guardian.Guard(func() (interface{}, error) {
-			sgs := make([]string, len(bClone.SharedGroups))
+			sgs := make([]string, len(bClone.SharedGroups)) // aici
 			i := 0
 			for sgID := range bClone.SharedGroups {
 				// add shared group member
diff --git a/engine/caches.go b/engine/caches.go
index 3e837c6ae..c0cfc5354 100644
--- a/engine/caches.go
+++ b/engine/caches.go
@@ -229,7 +229,8 @@ func (chS *CacheS) Precache() (err error) {
 		wg.Add(1)
 		go func(cacheID string) {
 			errCache := chS.dm.CacheDataFromDB(
-				utils.CacheInstanceToPrefix[cacheID], nil,
+				utils.CacheInstanceToPrefix[cacheID],
+				[]string{utils.MetaAny},
 				false)
 			if errCache != nil {
 				errChan <- fmt.Errorf("precaching cacheID <%s>, got error: %s", cacheID, errCache)
@@ -360,6 +361,14 @@ func (chS *CacheS) V1RemoveGroup(args *utils.ArgsGetGroupWithAPIOpts,
 }
 
 func (chS *CacheS) V1ReloadCache(attrs utils.AttrReloadCacheWithAPIOpts, reply *string) (err error) {
+	return chS.cacheDataFromDB(attrs, reply, true)
+}
+
+func (chS *CacheS) V1LoadCache(attrs utils.AttrReloadCacheWithAPIOpts, reply *string) (err error) {
+	return chS.cacheDataFromDB(attrs, reply, false)
+}
+
+func (chS *CacheS) cacheDataFromDB(attrs utils.AttrReloadCacheWithAPIOpts, reply *string, mustBeCached bool) (err error) {
 	for key, ids := range attrs.ArgsCache {
 		if prfx, has := utils.ArgCacheToPrefix[key]; has {
 			if err = chS.dm.CacheDataFromDB(prfx, ids, true); err != nil {
@@ -379,35 +388,8 @@ func (chS *CacheS) V1ReloadCache(attrs utils.AttrReloadCacheWithAPIOpts, reply *
 		chS.tCache.Set(utils.CacheLoadIDs, key, val, nil,
 			cacheCommit(utils.NonTransactional), utils.NonTransactional)
 	}
-
 	*reply = utils.OK
-	return nil
-}
-
-func (chS *CacheS) V1LoadCache(attrs utils.AttrReloadCacheWithAPIOpts, reply *string) (err error) {
-	args := make(map[string][]string)
-	for key, ids := range attrs.ArgsCache {
-		if prfx, has := utils.ArgCacheToPrefix[key]; has {
-			args[prfx] = ids
-		}
-	}
-	if err = chS.dm.LoadDataDBCache(args); err != nil {
-		return utils.NewErrServerError(err)
-	}
-	//get loadIDs for all types
-	var loadIDs map[string]int64
-	if loadIDs, err = chS.dm.GetItemLoadIDs(utils.EmptyString, false); err != nil {
-		if err != utils.ErrNotFound { // we can receive cache reload from LoaderS and we store the LoadID only after all Items was processed
-			return
-		}
-		loadIDs = make(map[string]int64)
-	}
-	for key, val := range populateCacheLoadIDs(loadIDs, attrs.ArgsCache) {
-		chS.tCache.Set(utils.CacheLoadIDs, key, val, nil,
-			cacheCommit(utils.NonTransactional), utils.NonTransactional)
-	}
-	*reply = utils.OK
-	return nil
+	return
 }
 
 //populateCacheLoadIDs populate cacheLoadIDs based on attrs
diff --git a/engine/datamanager.go b/engine/datamanager.go
index ac4b3b4b3..b05cf49a3 100644
--- a/engine/datamanager.go
+++ b/engine/datamanager.go
@@ -101,21 +101,6 @@ func (dm *DataManager) DataDB() DataDB {
 	return nil
 }
 
-func (dm *DataManager) LoadDataDBCache(attr map[string][]string) (err error) {
-	if dm == nil {
-		return utils.ErrNoDatabaseConn
-	}
-	if dm.DataDB().GetStorageType() == utils.INTERNAL {
-		return // all the data is in cache already
-	}
-	for key, ids := range attr {
-		if err = dm.CacheDataFromDB(key, ids, false); err != nil {
-			return
-		}
-	}
-	return
-}
-
 func (dm *DataManager) CacheDataFromDB(prfx string, ids []string, mustBeCached bool) (err error) {
 	if dm == nil {
 		return utils.ErrNoDatabaseConn
@@ -131,7 +116,7 @@ func (dm *DataManager) CacheDataFromDB(prfx string, ids []string, mustBeCached b
 	}
 	if prfx == utils.MetaAPIBan { // no need for ids in this case
 		ids = []string{utils.EmptyString}
-	} else if ids == nil {
+	} else if len(ids) != 0 && ids[0] == utils.MetaAny {
 		if mustBeCached {
 			ids = Cache.GetItemIDs(utils.CachePrefixToInstance[prfx], utils.EmptyString)
 		} else {
diff --git a/engine/libtest.go b/engine/libtest.go
index 16e5cabc5..1ba470fd1 100644
--- a/engine/libtest.go
+++ b/engine/libtest.go
@@ -562,37 +562,48 @@ func GetDefaultEmptyCacheStats() map[string]*ltcache.CacheStats {
 	}
 }
 
-func GetDefaultEmptyArgCachePrefix() map[string][]string {
-	return map[string][]string{
-		utils.DestinationPrefix:        nil,
-		utils.ReverseDestinationPrefix: nil,
-		utils.RatingPlanPrefix:         nil,
-		utils.RatingProfilePrefix:      nil,
-		utils.ActionPrefix:             nil,
-		utils.ActionPlanPrefix:         nil,
-		utils.AccountActionPlansPrefix: nil,
-		utils.ActionTriggerPrefix:      nil,
-		utils.SharedGroupPrefix:        nil,
-		utils.ResourceProfilesPrefix:   nil,
-		utils.ResourcesPrefix:          nil,
-		utils.StatQueuePrefix:          nil,
-		utils.StatQueueProfilePrefix:   nil,
-		utils.ThresholdPrefix:          nil,
-		utils.ThresholdProfilePrefix:   nil,
-		utils.FilterPrefix:             nil,
-		utils.RouteProfilePrefix:       nil,
-		utils.AttributeProfilePrefix:   nil,
-		utils.ChargerProfilePrefix:     nil,
-		utils.DispatcherProfilePrefix:  nil,
-		utils.DispatcherHostPrefix:     nil,
-		utils.TimingsPrefix:            nil,
-		utils.AttributeFilterIndexes:   nil,
-		utils.ResourceFilterIndexes:    nil,
-		utils.StatFilterIndexes:        nil,
-		utils.ThresholdFilterIndexes:   nil,
-		utils.RouteFilterIndexes:       nil,
-		utils.ChargerFilterIndexes:     nil,
-		utils.DispatcherFilterIndexes:  nil,
-		utils.FilterIndexPrfx:          nil,
+func LoadAllDataDBToCache(dm *DataManager) (err error) {
+	if dm == nil {
+		return utils.ErrNoDatabaseConn
 	}
+	if dm.DataDB().GetStorageType() == utils.INTERNAL {
+		return // all the data is in cache already
+	}
+	for key, ids := range map[string][]string{
+		utils.DestinationPrefix:        {utils.MetaAny},
+		utils.ReverseDestinationPrefix: {utils.MetaAny},
+		utils.RatingPlanPrefix:         {utils.MetaAny},
+		utils.RatingProfilePrefix:      {utils.MetaAny},
+		utils.ActionPrefix:             {utils.MetaAny},
+		utils.ActionPlanPrefix:         {utils.MetaAny},
+		utils.AccountActionPlansPrefix: {utils.MetaAny},
+		utils.ActionTriggerPrefix:      {utils.MetaAny},
+		utils.SharedGroupPrefix:        {utils.MetaAny},
+		utils.ResourceProfilesPrefix:   {utils.MetaAny},
+		utils.ResourcesPrefix:          {utils.MetaAny},
+		utils.StatQueuePrefix:          {utils.MetaAny},
+		utils.StatQueueProfilePrefix:   {utils.MetaAny},
+		utils.ThresholdPrefix:          {utils.MetaAny},
+		utils.ThresholdProfilePrefix:   {utils.MetaAny},
+		utils.FilterPrefix:             {utils.MetaAny},
+		utils.RouteProfilePrefix:       {utils.MetaAny},
+		utils.AttributeProfilePrefix:   {utils.MetaAny},
+		utils.ChargerProfilePrefix:     {utils.MetaAny},
+		utils.DispatcherProfilePrefix:  {utils.MetaAny},
+		utils.DispatcherHostPrefix:     {utils.MetaAny},
+		utils.TimingsPrefix:            {utils.MetaAny},
+		utils.AttributeFilterIndexes:   {utils.MetaAny},
+		utils.ResourceFilterIndexes:    {utils.MetaAny},
+		utils.StatFilterIndexes:        {utils.MetaAny},
+		utils.ThresholdFilterIndexes:   {utils.MetaAny},
+		utils.RouteFilterIndexes:       {utils.MetaAny},
+		utils.ChargerFilterIndexes:     {utils.MetaAny},
+		utils.DispatcherFilterIndexes:  {utils.MetaAny},
+		utils.FilterIndexPrfx:          {utils.MetaAny},
+	} {
+		if err = dm.CacheDataFromDB(key, ids, false); err != nil {
+			return
+		}
+	}
+	return
 }
diff --git a/engine/storage_test.go b/engine/storage_test.go
index f7e44c73b..075141f36 100644
--- a/engine/storage_test.go
+++ b/engine/storage_test.go
@@ -102,7 +102,7 @@ func TestStorageCacheRefresh(t *testing.T) {
 	dm.GetDestination("T11", false, utils.NonTransactional)
 	dm.SetDestination(&Destination{"T11", []string{"1"}}, utils.NonTransactional)
 	t.Log("Test cache refresh")
-	err := dm.LoadDataDBCache(GetDefaultEmptyArgCachePrefix())
+	err := LoadAllDataDBCache(dm)
 	if err != nil {
 		t.Error("Error cache rating: ", err)
 	}
diff --git a/general_tests/acntacts_test.go b/general_tests/acntacts_test.go
index b1e032309..863caa5c3 100644
--- a/general_tests/acntacts_test.go
+++ b/general_tests/acntacts_test.go
@@ -66,8 +66,7 @@ ENABLE_ACNT,*enable_account,,,,,,,,,,,,,false,false,10`
 		t.Fatal(err)
 	}
 	csvr.WriteToDatabase(false, false)
-
-	dbAcntActs.LoadDataDBCache(engine.GetDefaultEmptyArgCachePrefix())
+	engine.LoadAllDataDBToCache(dbAcntActs)
 
 	expectAcnt := &engine.Account{ID: "cgrates.org:1"}
 	if acnt, err := dbAcntActs.GetAccount("cgrates.org:1"); err != nil {
diff --git a/general_tests/auth_test.go b/general_tests/auth_test.go
index 0df896889..1e808517f 100644
--- a/general_tests/auth_test.go
+++ b/general_tests/auth_test.go
@@ -107,8 +107,7 @@ cgrates.org,call,*any,2013-01-06T00:00:00Z,RP_ANY,`
 	} else if acnt == nil {
 		t.Error("No account saved")
 	}
-
-	dbAuth.LoadDataDBCache(engine.GetDefaultEmptyArgCachePrefix())
+	engine.LoadAllDataDBToCache(dbAuth)
 
 	if cachedDests := len(engine.Cache.GetItemIDs(utils.CacheDestinations, "")); cachedDests != 1 {
 		t.Error("Wrong number of cached destinations found", cachedDests)
diff --git a/general_tests/costs1_test.go b/general_tests/costs1_test.go
index 9a45b083a..c6c26604d 100644
--- a/general_tests/costs1_test.go
+++ b/general_tests/costs1_test.go
@@ -83,7 +83,7 @@ cgrates.org,sms,*any,2012-01-01T00:00:00Z,RP_SMS1,`
 		t.Fatal(err)
 	}
 	csvr.WriteToDatabase(false, false)
-	dataDB.LoadDataDBCache(engine.GetDefaultEmptyArgCachePrefix())
+	engine.LoadAllDataDBToCache(dataDB)
 
 	if cachedRPlans := len(engine.Cache.GetItemIDs(utils.CacheRatingPlans, utils.EmptyString)); cachedRPlans != 3 {
 		t.Error("Wrong number of cached rating plans found", cachedRPlans)
diff --git a/general_tests/datachrg1_test.go b/general_tests/datachrg1_test.go
index dc246852d..38797f440 100644
--- a/general_tests/datachrg1_test.go
+++ b/general_tests/datachrg1_test.go
@@ -68,7 +68,7 @@ RP_DATA1,DR_DATA_2,TM2,10`
 		t.Fatal(err)
 	}
 	csvr.WriteToDatabase(false, false)
-	dataDB.LoadDataDBCache(engine.GetDefaultEmptyArgCachePrefix())
+	engine.LoadAllDataDBToCache(dataDB)
 
 	if cachedRPlans := len(engine.Cache.GetItemIDs(utils.CacheRatingPlans, utils.EmptyString)); cachedRPlans != 1 {
 		t.Error("Wrong number of cached rating plans found", cachedRPlans)
diff --git a/general_tests/ddazmbl1_test.go b/general_tests/ddazmbl1_test.go
index 00d1bec00..89dcd94c6 100644
--- a/general_tests/ddazmbl1_test.go
+++ b/general_tests/ddazmbl1_test.go
@@ -112,7 +112,7 @@ TOPUP10_AT,TOPUP10_AC1,ASAP,10`
 		t.Error("No account saved")
 	}
 
-	dataDB.LoadDataDBCache(engine.GetDefaultEmptyArgCachePrefix())
+	engine.LoadAllDataDBToCache(dataDB)
 
 	if cachedDests := len(engine.Cache.GetItemIDs(utils.CacheDestinations, "")); cachedDests != 1 {
 		t.Error("Wrong number of cached destinations found", cachedDests)
diff --git a/general_tests/ddazmbl2_test.go b/general_tests/ddazmbl2_test.go
index d068d1cc4..4ae636a5d 100644
--- a/general_tests/ddazmbl2_test.go
+++ b/general_tests/ddazmbl2_test.go
@@ -109,7 +109,7 @@ TOPUP10_AT,TOPUP10_AC1,ASAP,10`
 	} else if acnt == nil {
 		t.Error("No account saved")
 	}
-	dataDB2.LoadDataDBCache(engine.GetDefaultEmptyArgCachePrefix())
+	engine.LoadAllDataDBToCache(dataDB2)
 
 	if cachedDests := len(engine.Cache.GetItemIDs(utils.CacheDestinations, "")); cachedDests != 1 {
 		t.Error("Wrong number of cached destinations found", cachedDests)
diff --git a/general_tests/ddazmbl3_test.go b/general_tests/ddazmbl3_test.go
index c3eee4caa..28064e3ab 100644
--- a/general_tests/ddazmbl3_test.go
+++ b/general_tests/ddazmbl3_test.go
@@ -108,7 +108,7 @@ cgrates.org,call,discounted_minutes,2013-01-06T00:00:00Z,RP_UK_Mobile_BIG5_PKG,`
 	} else if acnt == nil {
 		t.Error("No account saved")
 	}
-	dataDB3.LoadDataDBCache(engine.GetDefaultEmptyArgCachePrefix())
+	engine.LoadAllDataDBToCache(dataDB3)
 
 	if cachedDests := len(engine.Cache.GetItemIDs(utils.CacheDestinations, "")); cachedDests != 1 {
 		t.Error("Wrong number of cached destinations found", cachedDests)
diff --git a/general_tests/smschrg1_test.go b/general_tests/smschrg1_test.go
index 60fa47926..6621ff895 100644
--- a/general_tests/smschrg1_test.go
+++ b/general_tests/smschrg1_test.go
@@ -68,7 +68,7 @@ func TestSMSLoadCsvTpSmsChrg1(t *testing.T) {
 		t.Fatal(err)
 	}
 	csvr.WriteToDatabase(false, false)
-	dataDB.LoadDataDBCache(engine.GetDefaultEmptyArgCachePrefix())
+	engine.LoadAllDataDBToCache(dataDB)
 
 	if cachedRPlans := len(engine.Cache.GetItemIDs(utils.CacheRatingPlans, utils.EmptyString)); cachedRPlans != 1 {
 		t.Error("Wrong number of cached rating plans found", cachedRPlans)