Feature/separate ts (#3190)

* created annotations for ts latest and created LatestDatabaseSchemaService for cassandra, hsql, psql, timescale

* created ts latest dao

* fixed tests and refactored

* refactored

* refactored

* created latest dao configs

* fix SqlTimeseriesDaoConfig

* refactoring, and deleted annotation @SqlDao

* refactoring

* created migration script for ts latest

* refactoring

Co-authored-by: Andrew Shvayka <ashvayka@thingsboard.io>

@@ -28,7 +28,9 @@ import org.thingsboard.server.service.install.DatabaseTsUpgradeService;
 import org.thingsboard.server.service.install.EntityDatabaseSchemaService;
 import org.thingsboard.server.service.install.EntityDatabaseSchemaService;
 import org.thingsboard.server.service.install.SystemDataLoaderService;
 import org.thingsboard.server.service.install.SystemDataLoaderService;
 import org.thingsboard.server.service.install.TsDatabaseSchemaService;
 import org.thingsboard.server.service.install.TsDatabaseSchemaService;
+import org.thingsboard.server.service.install.TsLatestDatabaseSchemaService;
 import org.thingsboard.server.service.install.migrate.EntitiesMigrateService;
 import org.thingsboard.server.service.install.migrate.EntitiesMigrateService;
+import org.thingsboard.server.service.install.migrate.TsLatestMigrateService;
 import org.thingsboard.server.service.install.update.DataUpdateService;
 import org.thingsboard.server.service.install.update.DataUpdateService;
 
 
 @Service
 @Service
@@ -51,6 +53,9 @@ public class ThingsboardInstallService {
     @Autowired
     @Autowired
     private TsDatabaseSchemaService tsDatabaseSchemaService;
     private TsDatabaseSchemaService tsDatabaseSchemaService;
 
 
+    @Autowired(required = false)
+    private TsLatestDatabaseSchemaService tsLatestDatabaseSchemaService;
+
     @Autowired
     @Autowired
     private DatabaseEntitiesUpgradeService databaseEntitiesUpgradeService;
     private DatabaseEntitiesUpgradeService databaseEntitiesUpgradeService;
 
 
@@ -72,6 +77,9 @@ public class ThingsboardInstallService {
     @Autowired(required = false)
     @Autowired(required = false)
     private EntitiesMigrateService entitiesMigrateService;
     private EntitiesMigrateService entitiesMigrateService;
 
 
+    @Autowired(required = false)
+    private TsLatestMigrateService latestMigrateService;
+
     public void performInstall() {
     public void performInstall() {
         try {
         try {
             if (isUpgrade) {
             if (isUpgrade) {
@@ -82,6 +90,10 @@ public class ThingsboardInstallService {
                     entitiesMigrateService.migrate();
                     entitiesMigrateService.migrate();
                     log.info("Updating system data...");
                     log.info("Updating system data...");
                     systemDataLoaderService.updateSystemWidgets();
                     systemDataLoaderService.updateSystemWidgets();
+                } else if ("3.0.1-cassandra".equals(upgradeFromVersion)) {
+                    log.info("Migrating ThingsBoard latest timeseries data from cassandra to SQL database ...");
+                    latestMigrateService.migrate();
+                    log.info("Updating system data...");
                 } else {
                 } else {
                     switch (upgradeFromVersion) {
                     switch (upgradeFromVersion) {
                         case "1.2.3": //NOSONAR, Need to execute gradual upgrade starting from upgradeFromVersion
                         case "1.2.3": //NOSONAR, Need to execute gradual upgrade starting from upgradeFromVersion
@@ -181,6 +193,10 @@ public class ThingsboardInstallService {
 
 
                 tsDatabaseSchemaService.createDatabaseSchema();
                 tsDatabaseSchemaService.createDatabaseSchema();
 
 
+                if (tsLatestDatabaseSchemaService != null) {
+                    tsLatestDatabaseSchemaService.createDatabaseSchema();
+                }
+
                 log.info("Loading system data...");
                 log.info("Loading system data...");
 
 
                 componentDiscoveryService.discoverComponents();
                 componentDiscoveryService.discoverComponents();

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.service.install;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.dao.util.NoSqlTsLatestDao;
+
+@Service
+@NoSqlTsLatestDao
+@Profile("install")
+public class CassandraTsLatestDatabaseSchemaService extends CassandraAbstractDatabaseSchemaService
+        implements TsLatestDatabaseSchemaService {
+    public CassandraTsLatestDatabaseSchemaService() {
+        super("schema-ts-latest.cql");
+    }
+}

@@ -18,11 +18,9 @@ package org.thingsboard.server.service.install;
 import org.springframework.context.annotation.Profile;
 import org.springframework.context.annotation.Profile;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.dao.util.HsqlDao;
 import org.thingsboard.server.dao.util.HsqlDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 @Service
 @Service
 @HsqlDao
 @HsqlDao
-@SqlDao
 @Profile("install")
 @Profile("install")
 public class HsqlEntityDatabaseSchemaService extends SqlAbstractDatabaseSchemaService
 public class HsqlEntityDatabaseSchemaService extends SqlAbstractDatabaseSchemaService
         implements EntityDatabaseSchemaService {
         implements EntityDatabaseSchemaService {

@@ -18,10 +18,8 @@ package org.thingsboard.server.service.install;
 import org.springframework.context.annotation.Profile;
 import org.springframework.context.annotation.Profile;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.dao.util.PsqlDao;
 import org.thingsboard.server.dao.util.PsqlDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 @Service
 @Service
-@SqlDao
 @PsqlDao
 @PsqlDao
 @Profile("install")
 @Profile("install")
 public class PsqlEntityDatabaseSchemaService extends SqlAbstractDatabaseSchemaService
 public class PsqlEntityDatabaseSchemaService extends SqlAbstractDatabaseSchemaService

@@ -21,7 +21,6 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Profile;
 import org.springframework.context.annotation.Profile;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.dao.dashboard.DashboardService;
 import org.thingsboard.server.dao.dashboard.DashboardService;
-import org.thingsboard.server.dao.util.SqlDao;
 import org.thingsboard.server.service.install.sql.SqlDbHelper;
 import org.thingsboard.server.service.install.sql.SqlDbHelper;
 
 
 import java.nio.charset.Charset;
 import java.nio.charset.Charset;
@@ -58,7 +57,6 @@ import static org.thingsboard.server.service.install.DatabaseHelper.TYPE;
 @Service
 @Service
 @Profile("install")
 @Profile("install")
 @Slf4j
 @Slf4j
-@SqlDao
 public class SqlDatabaseUpgradeService implements DatabaseEntitiesUpgradeService {
 public class SqlDatabaseUpgradeService implements DatabaseEntitiesUpgradeService {
 
 
     private static final String SCHEMA_UPDATE_SQL = "schema_update.sql";
     private static final String SCHEMA_UPDATE_SQL = "schema_update.sql";

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.service.install;
+
+public interface TsLatestDatabaseSchemaService extends DatabaseSchemaService {
+}

@@ -24,7 +24,6 @@ import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.UUIDConverter;
 import org.thingsboard.server.common.data.UUIDConverter;
 import org.thingsboard.server.dao.cassandra.CassandraCluster;
 import org.thingsboard.server.dao.cassandra.CassandraCluster;
 import org.thingsboard.server.dao.util.NoSqlAnyDao;
 import org.thingsboard.server.dao.util.NoSqlAnyDao;
-import org.thingsboard.server.dao.util.SqlDao;
 import org.thingsboard.server.service.install.EntityDatabaseSchemaService;
 import org.thingsboard.server.service.install.EntityDatabaseSchemaService;
 
 
 import java.sql.Connection;
 import java.sql.Connection;
@@ -42,7 +41,6 @@ import static org.thingsboard.server.service.install.migrate.CassandraToSqlColum
 
 
 @Service
 @Service
 @Profile("install")
 @Profile("install")
-@SqlDao
 @NoSqlAnyDao
 @NoSqlAnyDao
 @Slf4j
 @Slf4j
 public class CassandraEntitiesToSqlMigrateService implements EntitiesMigrateService {
 public class CassandraEntitiesToSqlMigrateService implements EntitiesMigrateService {

@@ -128,7 +128,7 @@ public class CassandraToSqlTable {
         return this.validateColumnData(data);
         return this.validateColumnData(data);
     }
     }
 
 
-    private CassandraToSqlColumnData[] validateColumnData(CassandraToSqlColumnData[] data) {
+    protected CassandraToSqlColumnData[] validateColumnData(CassandraToSqlColumnData[] data) {
         for (int i=0;i<data.length;i++) {
         for (int i=0;i<data.length;i++) {
             CassandraToSqlColumn column = this.columns.get(i);
             CassandraToSqlColumn column = this.columns.get(i);
             if (column.getType() == CassandraToSqlColumnType.STRING) {
             if (column.getType() == CassandraToSqlColumnType.STRING) {
@@ -148,7 +148,7 @@ public class CassandraToSqlTable {
         return data;
         return data;
     }
     }
 
 
-    private void batchInsert(List<CassandraToSqlColumnData[]> batchData, Connection conn) throws SQLException {
+    protected void batchInsert(List<CassandraToSqlColumnData[]> batchData, Connection conn) throws SQLException {
         boolean retry = false;
         boolean retry = false;
         for (CassandraToSqlColumnData[] data : batchData) {
         for (CassandraToSqlColumnData[] data : batchData) {
             for (CassandraToSqlColumn column: this.columns) {
             for (CassandraToSqlColumn column: this.columns) {
@@ -269,7 +269,7 @@ public class CassandraToSqlTable {
         return Optional.empty();
         return Optional.empty();
     }
     }
 
 
-    private Statement createCassandraSelectStatement() {
+    protected Statement createCassandraSelectStatement() {
         StringBuilder selectStatementBuilder = new StringBuilder();
         StringBuilder selectStatementBuilder = new StringBuilder();
         selectStatementBuilder.append("SELECT ");
         selectStatementBuilder.append("SELECT ");
         for (CassandraToSqlColumn column : columns) {
         for (CassandraToSqlColumn column : columns) {

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.service.install.migrate;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.hibernate.exception.ConstraintViolationException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.UUIDConverter;
+import org.thingsboard.server.dao.cassandra.CassandraCluster;
+import org.thingsboard.server.dao.model.sqlts.dictionary.TsKvDictionary;
+import org.thingsboard.server.dao.model.sqlts.dictionary.TsKvDictionaryCompositeKey;
+import org.thingsboard.server.dao.model.sqlts.latest.TsKvLatestEntity;
+import org.thingsboard.server.dao.sqlts.dictionary.TsKvDictionaryRepository;
+import org.thingsboard.server.dao.sqlts.insert.latest.InsertLatestTsRepository;
+import org.thingsboard.server.dao.util.NoSqlAnyDao;
+import org.thingsboard.server.service.install.EntityDatabaseSchemaService;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.stream.Collectors;
+
+import static org.thingsboard.server.service.install.migrate.CassandraToSqlColumn.bigintColumn;
+import static org.thingsboard.server.service.install.migrate.CassandraToSqlColumn.booleanColumn;
+import static org.thingsboard.server.service.install.migrate.CassandraToSqlColumn.doubleColumn;
+import static org.thingsboard.server.service.install.migrate.CassandraToSqlColumn.idColumn;
+import static org.thingsboard.server.service.install.migrate.CassandraToSqlColumn.jsonColumn;
+import static org.thingsboard.server.service.install.migrate.CassandraToSqlColumn.stringColumn;
+
+@Service
+@Profile("install")
+@NoSqlAnyDao
+@Slf4j
+public class CassandraTsLatestToSqlMigrateService implements TsLatestMigrateService {
+
+    @Autowired
+    private EntityDatabaseSchemaService entityDatabaseSchemaService;
+
+    @Autowired
+    private InsertLatestTsRepository insertLatestTsRepository;
+
+    @Autowired
+    protected CassandraCluster cluster;
+
+    @Autowired
+    protected TsKvDictionaryRepository dictionaryRepository;
+
+    @Value("${spring.datasource.url}")
+    protected String dbUrl;
+
+    @Value("${spring.datasource.username}")
+    protected String dbUserName;
+
+    @Value("${spring.datasource.password}")
+    protected String dbPassword;
+
+    private final ConcurrentMap<String, Integer> tsKvDictionaryMap = new ConcurrentHashMap<>();
+
+    protected static final ReentrantLock tsCreationLock = new ReentrantLock();
+
+    @Override
+    public void migrate() throws Exception {
+        log.info("Performing migration of latest timeseries data from cassandra to SQL database ...");
+        entityDatabaseSchemaService.createDatabaseSchema(false);
+        try (Connection conn = DriverManager.getConnection(dbUrl, dbUserName, dbPassword)) {
+            conn.setAutoCommit(false);
+            for (CassandraToSqlTable table : tables) {
+                table.migrateToSql(cluster.getSession(), conn);
+            }
+        } catch (Exception e) {
+            log.error("Unexpected error during ThingsBoard entities data migration!", e);
+            throw e;
+        }
+        entityDatabaseSchemaService.createDatabaseIndexes();
+    }
+
+    private List<CassandraToSqlTable> tables = Arrays.asList(
+            new CassandraToSqlTable("ts_kv_latest_cf",
+                    idColumn("entity_id"),
+                    stringColumn("key"),
+                    bigintColumn("ts"),
+                    booleanColumn("bool_v"),
+                    stringColumn("str_v"),
+                    bigintColumn("long_v"),
+                    doubleColumn("dbl_v"),
+                    jsonColumn("json_v")) {
+
+                @Override
+                protected void batchInsert(List<CassandraToSqlColumnData[]> batchData, Connection conn) {
+                    insertLatestTsRepository
+                            .saveOrUpdate(batchData.stream().map(data -> getTsKvLatestEntity(data)).collect(Collectors.toList()));
+                }
+
+                @Override
+                protected CassandraToSqlColumnData[] validateColumnData(CassandraToSqlColumnData[] data) {
+                    return data;
+                }
+            });
+
+    private TsKvLatestEntity getTsKvLatestEntity(CassandraToSqlColumnData[] data) {
+        TsKvLatestEntity latestEntity = new TsKvLatestEntity();
+        latestEntity.setEntityId(UUIDConverter.fromString(data[0].getValue()));
+        latestEntity.setKey(getOrSaveKeyId(data[1].getValue()));
+        latestEntity.setTs(Long.parseLong(data[2].getValue()));
+
+        String strV = data[4].getValue();
+        if (strV != null) {
+            latestEntity.setStrValue(strV);
+        } else {
+            Long longV = null;
+            try {
+                longV = Long.parseLong(data[5].getValue());
+            } catch (Exception e) {
+            }
+            if (longV != null) {
+                latestEntity.setLongValue(longV);
+            } else {
+                Double doubleV = null;
+                try {
+                    doubleV = Double.parseDouble(data[6].getValue());
+                } catch (Exception e) {
+                }
+                if (doubleV != null) {
+                    latestEntity.setDoubleValue(doubleV);
+                } else {
+
+                    String jsonV = data[7].getValue();
+                    if (StringUtils.isNoneEmpty(jsonV)) {
+                        latestEntity.setJsonValue(jsonV);
+                    } else {
+                        Boolean boolV = null;
+                        try {
+                            boolV = Boolean.parseBoolean(data[3].getValue());
+                        } catch (Exception e) {
+                        }
+                        if (boolV != null) {
+                            latestEntity.setBooleanValue(boolV);
+                        } else {
+                            log.warn("All values in key-value row are nullable ");
+                        }
+                    }
+                }
+            }
+        }
+        return latestEntity;
+    }
+
+    protected Integer getOrSaveKeyId(String strKey) {
+        Integer keyId = tsKvDictionaryMap.get(strKey);
+        if (keyId == null) {
+            Optional<TsKvDictionary> tsKvDictionaryOptional;
+            tsKvDictionaryOptional = dictionaryRepository.findById(new TsKvDictionaryCompositeKey(strKey));
+            if (!tsKvDictionaryOptional.isPresent()) {
+                tsCreationLock.lock();
+                try {
+                    tsKvDictionaryOptional = dictionaryRepository.findById(new TsKvDictionaryCompositeKey(strKey));
+                    if (!tsKvDictionaryOptional.isPresent()) {
+                        TsKvDictionary tsKvDictionary = new TsKvDictionary();
+                        tsKvDictionary.setKey(strKey);
+                        try {
+                            TsKvDictionary saved = dictionaryRepository.save(tsKvDictionary);
+                            tsKvDictionaryMap.put(saved.getKey(), saved.getKeyId());
+                            keyId = saved.getKeyId();
+                        } catch (ConstraintViolationException e) {
+                            tsKvDictionaryOptional = dictionaryRepository.findById(new TsKvDictionaryCompositeKey(strKey));
+                            TsKvDictionary dictionary = tsKvDictionaryOptional.orElseThrow(() -> new RuntimeException("Failed to get TsKvDictionary entity from DB!"));
+                            tsKvDictionaryMap.put(dictionary.getKey(), dictionary.getKeyId());
+                            keyId = dictionary.getKeyId();
+                        }
+                    } else {
+                        keyId = tsKvDictionaryOptional.get().getKeyId();
+                    }
+                } finally {
+                    tsCreationLock.unlock();
+                }
+            } else {
+                keyId = tsKvDictionaryOptional.get().getKeyId();
+                tsKvDictionaryMap.put(strKey, keyId);
+            }
+        }
+        return keyId;
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.service.install.migrate;
+
+public interface TsLatestMigrateService {
+
+    void migrate() throws Exception;
+}

@@ -28,7 +28,6 @@ import org.thingsboard.server.common.msg.TbActorMsg;
 import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.common.msg.queue.ServiceType;
 import org.thingsboard.server.common.msg.queue.TbCallback;
 import org.thingsboard.server.common.msg.queue.TbCallback;
 import org.thingsboard.server.dao.util.mapping.JacksonUtil;
 import org.thingsboard.server.dao.util.mapping.JacksonUtil;
-import org.thingsboard.server.gen.transport.TransportProtos;
 import org.thingsboard.server.gen.transport.TransportProtos.DeviceStateServiceMsgProto;
 import org.thingsboard.server.gen.transport.TransportProtos.DeviceStateServiceMsgProto;
 import org.thingsboard.server.gen.transport.TransportProtos.FromDeviceRPCResponseProto;
 import org.thingsboard.server.gen.transport.TransportProtos.FromDeviceRPCResponseProto;
 import org.thingsboard.server.gen.transport.TransportProtos.LocalSubscriptionServiceMsgProto;
 import org.thingsboard.server.gen.transport.TransportProtos.LocalSubscriptionServiceMsgProto;
@@ -61,7 +60,6 @@ import org.thingsboard.server.service.transport.msg.TransportToDeviceActorMsgWra
 
 
 import javax.annotation.PostConstruct;
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
 import javax.annotation.PreDestroy;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.List;
 import java.util.Optional;
 import java.util.Optional;
 import java.util.UUID;
 import java.util.UUID;

@@ -20,7 +20,6 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.dao.util.PsqlDao;
 import org.thingsboard.server.dao.util.PsqlDao;
-import org.thingsboard.server.dao.util.SqlDao;
 import org.thingsboard.server.service.ttl.AbstractCleanUpService;
 import org.thingsboard.server.service.ttl.AbstractCleanUpService;
 
 
 import java.sql.Connection;
 import java.sql.Connection;
@@ -28,7 +27,6 @@ import java.sql.DriverManager;
 import java.sql.SQLException;
 import java.sql.SQLException;
 
 
 @PsqlDao
 @PsqlDao
-@SqlDao
 @Slf4j
 @Slf4j
 @Service
 @Service
 public class EventsCleanUpService extends AbstractCleanUpService {
 public class EventsCleanUpService extends AbstractCleanUpService {

@@ -19,11 +19,13 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.dao.model.ModelConstants;
 import org.thingsboard.server.dao.model.ModelConstants;
-import org.thingsboard.server.dao.util.PsqlTsDao;
+import org.thingsboard.server.dao.util.PsqlDao;
+import org.thingsboard.server.dao.util.SqlTsDao;
 
 
 import java.sql.Connection;
 import java.sql.Connection;
 
 
-@PsqlTsDao
+@SqlTsDao
+@PsqlDao
 @Service
 @Service
 @Slf4j
 @Slf4j
 public class PsqlTimeseriesCleanUpService extends AbstractTimeseriesCleanUpService {
 public class PsqlTimeseriesCleanUpService extends AbstractTimeseriesCleanUpService {
@@ -33,9 +35,9 @@ public class PsqlTimeseriesCleanUpService extends AbstractTimeseriesCleanUpServi
 
 
     @Override
     @Override
     protected void doCleanUp(Connection connection) {
     protected void doCleanUp(Connection connection) {
-            long totalPartitionsRemoved = executeQuery(connection, "call drop_partitions_by_max_ttl('" + partitionType + "'," + systemTtl + ", 0);");
-            log.info("Total partitions removed by TTL: [{}]", totalPartitionsRemoved);
-            long totalEntitiesTelemetryRemoved = executeQuery(connection, "call cleanup_timeseries_by_ttl('" + ModelConstants.NULL_UUID + "'," + systemTtl + ", 0);");
-            log.info("Total telemetry removed stats by TTL for entities: [{}]", totalEntitiesTelemetryRemoved);
+        long totalPartitionsRemoved = executeQuery(connection, "call drop_partitions_by_max_ttl('" + partitionType + "'," + systemTtl + ", 0);");
+        log.info("Total partitions removed by TTL: [{}]", totalPartitionsRemoved);
+        long totalEntitiesTelemetryRemoved = executeQuery(connection, "call cleanup_timeseries_by_ttl('" + ModelConstants.NULL_UUID + "'," + systemTtl + ", 0);");
+        log.info("Total telemetry removed stats by TTL for entities: [{}]", totalEntitiesTelemetryRemoved);
     }
     }
 }
 }

@@ -178,8 +178,8 @@ database:
   ts_max_intervals: "${DATABASE_TS_MAX_INTERVALS:700}" # Max number of DB queries generated by single API call to fetch telemetry records
   ts_max_intervals: "${DATABASE_TS_MAX_INTERVALS:700}" # Max number of DB queries generated by single API call to fetch telemetry records
   ts:
   ts:
     type: "${DATABASE_TS_TYPE:sql}" # cassandra, sql, or timescale (for hybrid mode, DATABASE_TS_TYPE value should be cassandra, or timescale)
     type: "${DATABASE_TS_TYPE:sql}" # cassandra, sql, or timescale (for hybrid mode, DATABASE_TS_TYPE value should be cassandra, or timescale)
-  latest_ts:
-    type: "${DATABASE_TS_TYPE:sql}" # cassandra, sql, or timescale (for hybrid mode, DATABASE_TS_TYPE value should be cassandra, or timescale)
+  ts_latest:
+    type: "${DATABASE_TS_LATEST_TYPE:sql}" # cassandra, sql, or timescale (for hybrid mode, DATABASE_TS_TYPE value should be cassandra, or timescale)
 
 
 # note: timescale works only with postgreSQL database for DATABASE_ENTITIES_TYPE.
 # note: timescale works only with postgreSQL database for DATABASE_ENTITIES_TYPE.
 
 

@@ -41,7 +41,9 @@ public class MqttNoSqlTestSuite {
     public static CustomCassandraCQLUnit cassandraUnit =
     public static CustomCassandraCQLUnit cassandraUnit =
             new CustomCassandraCQLUnit(
             new CustomCassandraCQLUnit(
                     Arrays.asList(
                     Arrays.asList(
-                            new ClassPathCQLDataSet("cassandra/schema-ts.cql", false, false)),
+                            new ClassPathCQLDataSet("cassandra/schema-ts.cql", false, false),
+                            new ClassPathCQLDataSet("cassandra/schema-ts-latest.cql", false, false)
+                    ),
                     "cassandra-test.yaml", 30000l);
                     "cassandra-test.yaml", 30000l);
 
 
     @BeforeClass
     @BeforeClass

@@ -21,6 +21,6 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.RetentionPolicy;
 
 
 @Retention(RetentionPolicy.RUNTIME)
 @Retention(RetentionPolicy.RUNTIME)
-@ConditionalOnExpression("'${database.ts.type}'=='cassandra' || '${database.entities.type}'=='cassandra'")
+@ConditionalOnExpression("'${database.ts.type}'=='cassandra' || '${database.ts_latest.type}'=='cassandra'")
 public @interface NoSqlAnyDao {
 public @interface NoSqlAnyDao {
 }
 }

@@ -15,9 +15,12 @@
  */
  */
 package org.thingsboard.server.dao.util;
 package org.thingsboard.server.dao.util;
 
 
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+
 import java.lang.annotation.Retention;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.RetentionPolicy;
 
 
 @Retention(RetentionPolicy.RUNTIME)
 @Retention(RetentionPolicy.RUNTIME)
-public @interface SqlDao {
+@ConditionalOnProperty(prefix = "database.ts_latest", value = "type", havingValue = "cassandra")
+public @interface NoSqlTsLatestDao {
 }
 }

@@ -21,7 +21,7 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.RetentionPolicy;
 
 
 @Retention(RetentionPolicy.RUNTIME)
 @Retention(RetentionPolicy.RUNTIME)
-@ConditionalOnExpression("('${database.ts.type}'=='sql' || '${database.ts.type}'=='timescale') " +
+@ConditionalOnExpression("('${database.ts_latest.type}'=='sql' || '${database.ts_latest.type}'=='timescale') " +
         "&& '${spring.jpa.database-platform}'=='org.hibernate.dialect.PostgreSQLDialect'")
         "&& '${spring.jpa.database-platform}'=='org.hibernate.dialect.PostgreSQLDialect'")
-public @interface PsqlTsAnyDao {
+public @interface PsqlTsLatestAnyDao {
 }
 }

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.dao.util;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnExpression;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@ConditionalOnExpression("'${database.ts_latest.type}'=='sql' || '${database.ts_latest.type}'=='timescale'")
+public @interface SqlTsLatestAnyDao {
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.dao.util;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@ConditionalOnProperty(prefix = "database.ts_latest", value = "type", havingValue = "sql")
+public @interface SqlTsLatestDao {
+}

@@ -21,6 +21,6 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.RetentionPolicy;
 
 
 @Retention(RetentionPolicy.RUNTIME)
 @Retention(RetentionPolicy.RUNTIME)
-@ConditionalOnExpression("'${database.ts.type}'=='sql' || '${database.ts.type}'=='timescale'")
-public @interface SqlTsAnyDao {
+@ConditionalOnExpression("'${database.ts.type}'=='sql' || '${database.ts.type}'=='timescale' || '${database.ts_latest.type}'=='sql' || '${database.ts_latest.type}'=='timescale'")
+public @interface SqlTsOrTsLatestAnyDao {
 }
 }

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.dao.util;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+@ConditionalOnProperty(prefix = "database.ts_latest", value = "type", havingValue = "timescale")
+public @interface TimescaleDBTsLatestDao {
+}

@@ -21,5 +21,6 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.RetentionPolicy;
 
 
 @Retention(RetentionPolicy.RUNTIME)
 @Retention(RetentionPolicy.RUNTIME)
-@ConditionalOnExpression("'${database.ts.type}'=='sql' && '${spring.jpa.database-platform}'=='org.hibernate.dialect.PostgreSQLDialect'")
-public @interface PsqlTsDao { }
+@ConditionalOnExpression("'${database.ts.type}'=='timescale' || '${database.ts_latest.type}'=='timescale'")
+public @interface TimescaleDBTsOrTsLatestDao {
+}

@@ -27,8 +27,8 @@ import org.thingsboard.server.dao.util.SqlTsDao;
 @Configuration
 @Configuration
 @EnableAutoConfiguration
 @EnableAutoConfiguration
 @ComponentScan({"org.thingsboard.server.dao.sqlts.hsql"})
 @ComponentScan({"org.thingsboard.server.dao.sqlts.hsql"})
-@EnableJpaRepositories({"org.thingsboard.server.dao.sqlts.ts", "org.thingsboard.server.dao.sqlts.insert.hsql", "org.thingsboard.server.dao.sqlts.insert.latest.hsql", "org.thingsboard.server.dao.sqlts.latest", "org.thingsboard.server.dao.sqlts.dictionary"})
-@EntityScan({"org.thingsboard.server.dao.model.sqlts.ts", "org.thingsboard.server.dao.model.sqlts.latest", "org.thingsboard.server.dao.model.sqlts.dictionary"})
+@EnableJpaRepositories({"org.thingsboard.server.dao.sqlts.ts", "org.thingsboard.server.dao.sqlts.insert.hsql"})
+@EntityScan({"org.thingsboard.server.dao.model.sqlts.ts"})
 @EnableTransactionManagement
 @EnableTransactionManagement
 @SqlTsDao
 @SqlTsDao
 @HsqlDao
 @HsqlDao

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.dao;
+
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.autoconfigure.domain.EntityScan;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+import org.thingsboard.server.dao.util.HsqlDao;
+import org.thingsboard.server.dao.util.SqlTsLatestDao;
+
+@Configuration
+@EnableAutoConfiguration
+@ComponentScan({"org.thingsboard.server.dao.sqlts.hsql"})
+@EnableJpaRepositories({"org.thingsboard.server.dao.sqlts.insert.latest.hsql", "org.thingsboard.server.dao.sqlts.latest"})
+@EntityScan({"org.thingsboard.server.dao.model.sqlts.latest"})
+@EnableTransactionManagement
+@SqlTsLatestDao
+@HsqlDao
+public class HsqlTsLatestDaoConfig {
+
+}

@@ -21,7 +21,6 @@ import org.springframework.context.annotation.ComponentScan;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
 import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
 import org.springframework.transaction.annotation.EnableTransactionManagement;
 import org.springframework.transaction.annotation.EnableTransactionManagement;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 /**
 /**
  * @author Valerii Sosliuk
  * @author Valerii Sosliuk
@@ -32,7 +31,6 @@ import org.thingsboard.server.dao.util.SqlDao;
 @EnableJpaRepositories("org.thingsboard.server.dao.sql")
 @EnableJpaRepositories("org.thingsboard.server.dao.sql")
 @EntityScan("org.thingsboard.server.dao.model.sql")
 @EntityScan("org.thingsboard.server.dao.model.sql")
 @EnableTransactionManagement
 @EnableTransactionManagement
-@SqlDao
 public class JpaDaoConfig {
 public class JpaDaoConfig {
 
 
 }
 }

@@ -27,11 +27,11 @@ import org.thingsboard.server.dao.util.SqlTsDao;
 @Configuration
 @Configuration
 @EnableAutoConfiguration
 @EnableAutoConfiguration
 @ComponentScan({"org.thingsboard.server.dao.sqlts.psql"})
 @ComponentScan({"org.thingsboard.server.dao.sqlts.psql"})
-@EnableJpaRepositories({"org.thingsboard.server.dao.sqlts.ts", "org.thingsboard.server.dao.sqlts.insert.psql", "org.thingsboard.server.dao.sqlts.insert.latest.psql", "org.thingsboard.server.dao.sqlts.latest", "org.thingsboard.server.dao.sqlts.dictionary"})
-@EntityScan({"org.thingsboard.server.dao.model.sqlts.ts", "org.thingsboard.server.dao.model.sqlts.latest", "org.thingsboard.server.dao.model.sqlts.dictionary"})
+@EnableJpaRepositories({"org.thingsboard.server.dao.sqlts.ts", "org.thingsboard.server.dao.sqlts.insert.psql"})
+@EntityScan({"org.thingsboard.server.dao.model.sqlts.ts"})
 @EnableTransactionManagement
 @EnableTransactionManagement
-@SqlTsDao
 @PsqlDao
 @PsqlDao
+@SqlTsDao
 public class PsqlTsDaoConfig {
 public class PsqlTsDaoConfig {
 
 
 }
 }

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.dao;
+
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.autoconfigure.domain.EntityScan;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+import org.thingsboard.server.dao.util.PsqlDao;
+import org.thingsboard.server.dao.util.SqlTsLatestDao;
+
+@Configuration
+@EnableAutoConfiguration
+@ComponentScan({"org.thingsboard.server.dao.sqlts.psql"})
+@EnableJpaRepositories({"org.thingsboard.server.dao.sqlts.insert.latest.psql", "org.thingsboard.server.dao.sqlts.latest"})
+@EntityScan({"org.thingsboard.server.dao.model.sqlts.latest"})
+@EnableTransactionManagement
+@SqlTsLatestDao
+@PsqlDao
+public class PsqlTsLatestDaoConfig {
+
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.dao;
+
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.autoconfigure.domain.EntityScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+import org.thingsboard.server.dao.util.PsqlDao;
+import org.thingsboard.server.dao.util.SqlTsOrTsLatestAnyDao;
+
+@Configuration
+@EnableAutoConfiguration
+@EnableJpaRepositories({"org.thingsboard.server.dao.sqlts.dictionary"})
+@EntityScan({"org.thingsboard.server.dao.model.sqlts.dictionary"})
+@EnableTransactionManagement
+@SqlTsOrTsLatestAnyDao
+public class SqlTimeseriesDaoConfig {
+
+}

@@ -27,8 +27,8 @@ import org.thingsboard.server.dao.util.TimescaleDBTsDao;
 @Configuration
 @Configuration
 @EnableAutoConfiguration
 @EnableAutoConfiguration
 @ComponentScan({"org.thingsboard.server.dao.sqlts.timescale"})
 @ComponentScan({"org.thingsboard.server.dao.sqlts.timescale"})
-@EnableJpaRepositories({"org.thingsboard.server.dao.sqlts.timescale", "org.thingsboard.server.dao.sqlts.insert.latest.psql", "org.thingsboard.server.dao.sqlts.insert.timescale", "org.thingsboard.server.dao.sqlts.dictionary", "org.thingsboard.server.dao.sqlts.latest"})
-@EntityScan({"org.thingsboard.server.dao.model.sqlts.timescale", "org.thingsboard.server.dao.model.sqlts.dictionary", "org.thingsboard.server.dao.model.sqlts.latest"})
+@EnableJpaRepositories({"org.thingsboard.server.dao.sqlts.timescale", "org.thingsboard.server.dao.sqlts.insert.timescale"})
+@EntityScan({"org.thingsboard.server.dao.model.sqlts.timescale"})
 @EnableTransactionManagement
 @EnableTransactionManagement
 @TimescaleDBTsDao
 @TimescaleDBTsDao
 @PsqlDao
 @PsqlDao

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.dao;
+
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.boot.autoconfigure.domain.EntityScan;
+import org.springframework.context.annotation.ComponentScan;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
+import org.springframework.transaction.annotation.EnableTransactionManagement;
+import org.thingsboard.server.dao.util.PsqlDao;
+import org.thingsboard.server.dao.util.TimescaleDBTsLatestDao;
+
+@Configuration
+@EnableAutoConfiguration
+@ComponentScan({"org.thingsboard.server.dao.sqlts.timescale"})
+@EnableJpaRepositories({"org.thingsboard.server.dao.sqlts.insert.latest.psql", "org.thingsboard.server.dao.sqlts.latest"})
+@EntityScan({"org.thingsboard.server.dao.model.sqlts.latest"})
+@EnableTransactionManagement
+@TimescaleDBTsLatestDao
+@PsqlDao
+public class TimescaleTsLatestDaoConfig {
+
+}

@@ -18,10 +18,8 @@ package org.thingsboard.server.dao.sql;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Component;
 import org.thingsboard.common.util.AbstractListeningExecutor;
 import org.thingsboard.common.util.AbstractListeningExecutor;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 @Component
 @Component
-@SqlDao
 public class JpaExecutorService extends AbstractListeningExecutor {
 public class JpaExecutorService extends AbstractListeningExecutor {
 
 
     @Value("${spring.datasource.hikari.maximumPoolSize}")
     @Value("${spring.datasource.hikari.maximumPoolSize}")

@@ -21,25 +21,15 @@ import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.data.repository.query.Param;
 import org.springframework.data.repository.query.Param;
 import org.thingsboard.server.common.data.alarm.AlarmStatus;
 import org.thingsboard.server.common.data.alarm.AlarmStatus;
-import org.thingsboard.server.common.data.id.CustomerId;
-import org.thingsboard.server.common.data.id.EntityId;
-import org.thingsboard.server.common.data.id.TenantId;
-import org.thingsboard.server.common.data.page.PageData;
-import org.thingsboard.server.common.data.query.AlarmData;
-import org.thingsboard.server.common.data.query.AlarmDataQuery;
 import org.thingsboard.server.dao.model.sql.AlarmEntity;
 import org.thingsboard.server.dao.model.sql.AlarmEntity;
 import org.thingsboard.server.dao.model.sql.AlarmInfoEntity;
 import org.thingsboard.server.dao.model.sql.AlarmInfoEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
-import java.util.Collection;
 import java.util.List;
 import java.util.List;
-import java.util.Set;
 import java.util.UUID;
 import java.util.UUID;
 
 
 /**
 /**
  * Created by Valerii Sosliuk on 5/21/2017.
  * Created by Valerii Sosliuk on 5/21/2017.
  */
  */
-@SqlDao
 public interface AlarmRepository extends CrudRepository<AlarmEntity, UUID> {
 public interface AlarmRepository extends CrudRepository<AlarmEntity, UUID> {
 
 
     @Query("SELECT a FROM AlarmEntity a WHERE a.originatorId = :originatorId AND a.type = :alarmType ORDER BY a.startTs DESC")
     @Query("SELECT a FROM AlarmEntity a WHERE a.originatorId = :originatorId AND a.type = :alarmType ORDER BY a.startTs DESC")

@@ -39,7 +39,6 @@ import org.thingsboard.server.dao.model.sql.AlarmEntity;
 import org.thingsboard.server.dao.relation.RelationDao;
 import org.thingsboard.server.dao.relation.RelationDao;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
 import org.thingsboard.server.dao.sql.query.AlarmQueryRepository;
 import org.thingsboard.server.dao.sql.query.AlarmQueryRepository;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.ArrayList;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collection;
@@ -54,7 +53,6 @@ import java.util.UUID;
  */
  */
 @Slf4j
 @Slf4j
 @Component
 @Component
-@SqlDao
 public class JpaAlarmDao extends JpaAbstractDao<AlarmEntity, Alarm> implements AlarmDao {
 public class JpaAlarmDao extends JpaAbstractDao<AlarmEntity, Alarm> implements AlarmDao {
 
 
     @Autowired
     @Autowired

@@ -22,7 +22,6 @@ import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.query.Param;
 import org.springframework.data.repository.query.Param;
 import org.thingsboard.server.dao.model.sql.AssetEntity;
 import org.thingsboard.server.dao.model.sql.AssetEntity;
 import org.thingsboard.server.dao.model.sql.AssetInfoEntity;
 import org.thingsboard.server.dao.model.sql.AssetInfoEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.List;
 import java.util.List;
 import java.util.UUID;
 import java.util.UUID;
@@ -30,7 +29,6 @@ import java.util.UUID;
 /**
 /**
  * Created by Valerii Sosliuk on 5/21/2017.
  * Created by Valerii Sosliuk on 5/21/2017.
  */
  */
-@SqlDao
 public interface AssetRepository extends PagingAndSortingRepository<AssetEntity, UUID> {
 public interface AssetRepository extends PagingAndSortingRepository<AssetEntity, UUID> {
 
 
     @Query("SELECT new org.thingsboard.server.dao.model.sql.AssetInfoEntity(a, c.title, c.additionalInfo) " +
     @Query("SELECT new org.thingsboard.server.dao.model.sql.AssetInfoEntity(a, c.title, c.additionalInfo) " +

@@ -31,7 +31,6 @@ import org.thingsboard.server.dao.asset.AssetDao;
 import org.thingsboard.server.dao.model.sql.AssetEntity;
 import org.thingsboard.server.dao.model.sql.AssetEntity;
 import org.thingsboard.server.dao.model.sql.AssetInfoEntity;
 import org.thingsboard.server.dao.model.sql.AssetInfoEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.ArrayList;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Collections;
@@ -44,7 +43,6 @@ import java.util.UUID;
  * Created by Valerii Sosliuk on 5/19/2017.
  * Created by Valerii Sosliuk on 5/19/2017.
  */
  */
 @Component
 @Component
-@SqlDao
 public class JpaAssetDao extends JpaAbstractSearchTextDao<AssetEntity, Asset> implements AssetDao {
 public class JpaAssetDao extends JpaAbstractSearchTextDao<AssetEntity, Asset> implements AssetDao {
 
 
     @Autowired
     @Autowired

@@ -25,7 +25,6 @@ import org.springframework.transaction.TransactionStatus;
 import org.springframework.transaction.support.TransactionCallbackWithoutResult;
 import org.springframework.transaction.support.TransactionCallbackWithoutResult;
 import org.springframework.transaction.support.TransactionTemplate;
 import org.springframework.transaction.support.TransactionTemplate;
 import org.thingsboard.server.dao.model.sql.AttributeKvEntity;
 import org.thingsboard.server.dao.model.sql.AttributeKvEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.sql.PreparedStatement;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.sql.SQLException;
@@ -35,7 +34,6 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.List;
 import java.util.regex.Pattern;
 import java.util.regex.Pattern;
 
 
-@SqlDao
 @Repository
 @Repository
 @Slf4j
 @Slf4j
 public abstract class AttributeKvInsertRepository {
 public abstract class AttributeKvInsertRepository {

@@ -23,12 +23,10 @@ import org.springframework.transaction.annotation.Transactional;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.dao.model.sql.AttributeKvCompositeKey;
 import org.thingsboard.server.dao.model.sql.AttributeKvCompositeKey;
 import org.thingsboard.server.dao.model.sql.AttributeKvEntity;
 import org.thingsboard.server.dao.model.sql.AttributeKvEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.List;
 import java.util.List;
 import java.util.UUID;
 import java.util.UUID;
 
 
-@SqlDao
 public interface AttributeKvRepository extends CrudRepository<AttributeKvEntity, AttributeKvCompositeKey> {
 public interface AttributeKvRepository extends CrudRepository<AttributeKvEntity, AttributeKvCompositeKey> {
 
 
     @Query("SELECT a FROM AttributeKvEntity a WHERE a.id.entityType = :entityType " +
     @Query("SELECT a FROM AttributeKvEntity a WHERE a.id.entityType = :entityType " +

@@ -19,12 +19,10 @@ import org.springframework.stereotype.Repository;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.annotation.Transactional;
 import org.thingsboard.server.dao.model.sql.AttributeKvEntity;
 import org.thingsboard.server.dao.model.sql.AttributeKvEntity;
 import org.thingsboard.server.dao.util.HsqlDao;
 import org.thingsboard.server.dao.util.HsqlDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.sql.Types;
 import java.sql.Types;
 import java.util.List;
 import java.util.List;
 
 
-@SqlDao
 @HsqlDao
 @HsqlDao
 @Repository
 @Repository
 @Transactional
 @Transactional

@@ -34,7 +34,6 @@ import org.thingsboard.server.dao.sql.JpaAbstractDaoListeningExecutorService;
 import org.thingsboard.server.dao.sql.ScheduledLogExecutorComponent;
 import org.thingsboard.server.dao.sql.ScheduledLogExecutorComponent;
 import org.thingsboard.server.dao.sql.TbSqlBlockingQueueParams;
 import org.thingsboard.server.dao.sql.TbSqlBlockingQueueParams;
 import org.thingsboard.server.dao.sql.TbSqlBlockingQueueWrapper;
 import org.thingsboard.server.dao.sql.TbSqlBlockingQueueWrapper;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import javax.annotation.PostConstruct;
 import javax.annotation.PostConstruct;
 import javax.annotation.PreDestroy;
 import javax.annotation.PreDestroy;
@@ -46,7 +45,6 @@ import java.util.stream.Collectors;
 
 
 @Component
 @Component
 @Slf4j
 @Slf4j
-@SqlDao
 public class JpaAttributeDao extends JpaAbstractDaoListeningExecutorService implements AttributesDao {
 public class JpaAttributeDao extends JpaAbstractDaoListeningExecutorService implements AttributesDao {
 
 
     @Autowired
     @Autowired

@@ -18,9 +18,7 @@ package org.thingsboard.server.dao.sql.attributes;
 import org.springframework.stereotype.Repository;
 import org.springframework.stereotype.Repository;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.annotation.Transactional;
 import org.thingsboard.server.dao.util.PsqlDao;
 import org.thingsboard.server.dao.util.PsqlDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
-@SqlDao
 @PsqlDao
 @PsqlDao
 @Repository
 @Repository
 @Transactional
 @Transactional

@@ -30,14 +30,12 @@ import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.audit.AuditLogDao;
 import org.thingsboard.server.dao.audit.AuditLogDao;
 import org.thingsboard.server.dao.model.sql.AuditLogEntity;
 import org.thingsboard.server.dao.model.sql.AuditLogEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.List;
 import java.util.List;
 import java.util.Objects;
 import java.util.Objects;
 import java.util.UUID;
 import java.util.UUID;
 
 
 @Component
 @Component
-@SqlDao
 public class JpaAuditLogDao extends JpaAbstractDao<AuditLogEntity, AuditLog> implements AuditLogDao {
 public class JpaAuditLogDao extends JpaAbstractDao<AuditLogEntity, AuditLog> implements AuditLogDao {
 
 
     @Autowired
     @Autowired

@@ -23,14 +23,12 @@ import org.springframework.data.repository.query.Param;
 import org.thingsboard.server.common.data.plugin.ComponentScope;
 import org.thingsboard.server.common.data.plugin.ComponentScope;
 import org.thingsboard.server.common.data.plugin.ComponentType;
 import org.thingsboard.server.common.data.plugin.ComponentType;
 import org.thingsboard.server.dao.model.sql.ComponentDescriptorEntity;
 import org.thingsboard.server.dao.model.sql.ComponentDescriptorEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.UUID;
 import java.util.UUID;
 
 
 /**
 /**
  * Created by Valerii Sosliuk on 5/6/2017.
  * Created by Valerii Sosliuk on 5/6/2017.
  */
  */
-@SqlDao
 public interface ComponentDescriptorRepository extends PagingAndSortingRepository<ComponentDescriptorEntity, UUID> {
 public interface ComponentDescriptorRepository extends PagingAndSortingRepository<ComponentDescriptorEntity, UUID> {
 
 
     ComponentDescriptorEntity findByClazz(String clazz);
     ComponentDescriptorEntity findByClazz(String clazz);

@@ -18,11 +18,9 @@ package org.thingsboard.server.dao.sql.component;
 import org.springframework.stereotype.Repository;
 import org.springframework.stereotype.Repository;
 import org.thingsboard.server.dao.model.sql.ComponentDescriptorEntity;
 import org.thingsboard.server.dao.model.sql.ComponentDescriptorEntity;
 import org.thingsboard.server.dao.util.HsqlDao;
 import org.thingsboard.server.dao.util.HsqlDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import javax.persistence.Query;
 import javax.persistence.Query;
 
 
-@SqlDao
 @HsqlDao
 @HsqlDao
 @Repository
 @Repository
 public class HsqlComponentDescriptorInsertRepository extends AbstractComponentDescriptorInsertRepository {
 public class HsqlComponentDescriptorInsertRepository extends AbstractComponentDescriptorInsertRepository {

@@ -31,7 +31,6 @@ import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.component.ComponentDescriptorDao;
 import org.thingsboard.server.dao.component.ComponentDescriptorDao;
 import org.thingsboard.server.dao.model.sql.ComponentDescriptorEntity;
 import org.thingsboard.server.dao.model.sql.ComponentDescriptorEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.Objects;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Optional;
@@ -41,7 +40,6 @@ import java.util.UUID;
  * Created by Valerii Sosliuk on 5/6/2017.
  * Created by Valerii Sosliuk on 5/6/2017.
  */
  */
 @Component
 @Component
-@SqlDao
 public class JpaBaseComponentDescriptorDao extends JpaAbstractSearchTextDao<ComponentDescriptorEntity, ComponentDescriptor>
 public class JpaBaseComponentDescriptorDao extends JpaAbstractSearchTextDao<ComponentDescriptorEntity, ComponentDescriptor>
         implements ComponentDescriptorDao {
         implements ComponentDescriptorDao {
 
 

@@ -18,9 +18,7 @@ package org.thingsboard.server.dao.sql.component;
 import org.springframework.stereotype.Repository;
 import org.springframework.stereotype.Repository;
 import org.thingsboard.server.dao.model.sql.ComponentDescriptorEntity;
 import org.thingsboard.server.dao.model.sql.ComponentDescriptorEntity;
 import org.thingsboard.server.dao.util.PsqlDao;
 import org.thingsboard.server.dao.util.PsqlDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
-@SqlDao
 @PsqlDao
 @PsqlDao
 @Repository
 @Repository
 public class PsqlComponentDescriptorInsertRepository extends AbstractComponentDescriptorInsertRepository {
 public class PsqlComponentDescriptorInsertRepository extends AbstractComponentDescriptorInsertRepository {

@@ -21,14 +21,12 @@ import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.query.Param;
 import org.springframework.data.repository.query.Param;
 import org.thingsboard.server.dao.model.sql.CustomerEntity;
 import org.thingsboard.server.dao.model.sql.CustomerEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.UUID;
 import java.util.UUID;
 
 
 /**
 /**
  * Created by Valerii Sosliuk on 5/6/2017.
  * Created by Valerii Sosliuk on 5/6/2017.
  */
  */
-@SqlDao
 public interface CustomerRepository extends PagingAndSortingRepository<CustomerEntity, UUID> {
 public interface CustomerRepository extends PagingAndSortingRepository<CustomerEntity, UUID> {
 
 
     @Query("SELECT c FROM CustomerEntity c WHERE c.tenantId = :tenantId " +
     @Query("SELECT c FROM CustomerEntity c WHERE c.tenantId = :tenantId " +

@@ -25,7 +25,6 @@ import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.customer.CustomerDao;
 import org.thingsboard.server.dao.customer.CustomerDao;
 import org.thingsboard.server.dao.model.sql.CustomerEntity;
 import org.thingsboard.server.dao.model.sql.CustomerEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.Objects;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Optional;
@@ -35,7 +34,6 @@ import java.util.UUID;
  * Created by Valerii Sosliuk on 5/6/2017.
  * Created by Valerii Sosliuk on 5/6/2017.
  */
  */
 @Component
 @Component
-@SqlDao
 public class JpaCustomerDao extends JpaAbstractSearchTextDao<CustomerEntity, Customer> implements CustomerDao {
 public class JpaCustomerDao extends JpaAbstractSearchTextDao<CustomerEntity, Customer> implements CustomerDao {
 
 
     @Autowired
     @Autowired

@@ -21,14 +21,12 @@ import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.query.Param;
 import org.springframework.data.repository.query.Param;
 import org.thingsboard.server.dao.model.sql.DashboardInfoEntity;
 import org.thingsboard.server.dao.model.sql.DashboardInfoEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.UUID;
 import java.util.UUID;
 
 
 /**
 /**
  * Created by Valerii Sosliuk on 5/6/2017.
  * Created by Valerii Sosliuk on 5/6/2017.
  */
  */
-@SqlDao
 public interface DashboardInfoRepository extends PagingAndSortingRepository<DashboardInfoEntity, UUID> {
 public interface DashboardInfoRepository extends PagingAndSortingRepository<DashboardInfoEntity, UUID> {
 
 
     @Query("SELECT di FROM DashboardInfoEntity di WHERE di.tenantId = :tenantId " +
     @Query("SELECT di FROM DashboardInfoEntity di WHERE di.tenantId = :tenantId " +

@@ -17,13 +17,11 @@ package org.thingsboard.server.dao.sql.dashboard;
 
 
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.data.repository.CrudRepository;
 import org.thingsboard.server.dao.model.sql.DashboardEntity;
 import org.thingsboard.server.dao.model.sql.DashboardEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.UUID;
 import java.util.UUID;
 
 
 /**
 /**
  * Created by Valerii Sosliuk on 5/6/2017.
  * Created by Valerii Sosliuk on 5/6/2017.
  */
  */
-@SqlDao
 public interface DashboardRepository extends CrudRepository<DashboardEntity, UUID> {
 public interface DashboardRepository extends CrudRepository<DashboardEntity, UUID> {
 }
 }

@@ -22,7 +22,6 @@ import org.thingsboard.server.common.data.Dashboard;
 import org.thingsboard.server.dao.dashboard.DashboardDao;
 import org.thingsboard.server.dao.dashboard.DashboardDao;
 import org.thingsboard.server.dao.model.sql.DashboardEntity;
 import org.thingsboard.server.dao.model.sql.DashboardEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.UUID;
 import java.util.UUID;
 
 
@@ -30,7 +29,6 @@ import java.util.UUID;
  * Created by Valerii Sosliuk on 5/6/2017.
  * Created by Valerii Sosliuk on 5/6/2017.
  */
  */
 @Component
 @Component
-@SqlDao
 public class JpaDashboardDao extends JpaAbstractSearchTextDao<DashboardEntity, Dashboard> implements DashboardDao {
 public class JpaDashboardDao extends JpaAbstractSearchTextDao<DashboardEntity, Dashboard> implements DashboardDao {
 
 
     @Autowired
     @Autowired

@@ -27,7 +27,6 @@ import org.thingsboard.server.dao.dashboard.DashboardInfoDao;
 import org.thingsboard.server.dao.model.sql.DashboardInfoEntity;
 import org.thingsboard.server.dao.model.sql.DashboardInfoEntity;
 import org.thingsboard.server.dao.relation.RelationDao;
 import org.thingsboard.server.dao.relation.RelationDao;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.Objects;
 import java.util.Objects;
 import java.util.UUID;
 import java.util.UUID;
@@ -37,7 +36,6 @@ import java.util.UUID;
  */
  */
 @Slf4j
 @Slf4j
 @Component
 @Component
-@SqlDao
 public class JpaDashboardInfoDao extends JpaAbstractSearchTextDao<DashboardInfoEntity, DashboardInfo> implements DashboardInfoDao {
 public class JpaDashboardInfoDao extends JpaAbstractSearchTextDao<DashboardInfoEntity, DashboardInfo> implements DashboardInfoDao {
 
 
     @Autowired
     @Autowired

@@ -17,14 +17,12 @@ package org.thingsboard.server.dao.sql.device;
 
 
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.data.repository.CrudRepository;
 import org.thingsboard.server.dao.model.sql.DeviceCredentialsEntity;
 import org.thingsboard.server.dao.model.sql.DeviceCredentialsEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.UUID;
 import java.util.UUID;
 
 
 /**
 /**
  * Created by Valerii Sosliuk on 5/6/2017.
  * Created by Valerii Sosliuk on 5/6/2017.
  */
  */
-@SqlDao
 public interface DeviceCredentialsRepository extends CrudRepository<DeviceCredentialsEntity, UUID> {
 public interface DeviceCredentialsRepository extends CrudRepository<DeviceCredentialsEntity, UUID> {
 
 
     DeviceCredentialsEntity findByDeviceId(UUID deviceId);
     DeviceCredentialsEntity findByDeviceId(UUID deviceId);

@@ -22,7 +22,6 @@ import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.query.Param;
 import org.springframework.data.repository.query.Param;
 import org.thingsboard.server.dao.model.sql.DeviceEntity;
 import org.thingsboard.server.dao.model.sql.DeviceEntity;
 import org.thingsboard.server.dao.model.sql.DeviceInfoEntity;
 import org.thingsboard.server.dao.model.sql.DeviceInfoEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.List;
 import java.util.List;
 import java.util.UUID;
 import java.util.UUID;
@@ -30,7 +29,6 @@ import java.util.UUID;
 /**
 /**
  * Created by Valerii Sosliuk on 5/6/2017.
  * Created by Valerii Sosliuk on 5/6/2017.
  */
  */
-@SqlDao
 public interface DeviceRepository extends PagingAndSortingRepository<DeviceEntity, UUID> {
 public interface DeviceRepository extends PagingAndSortingRepository<DeviceEntity, UUID> {
 
 
     @Query("SELECT new org.thingsboard.server.dao.model.sql.DeviceInfoEntity(d, c.title, c.additionalInfo) " +
     @Query("SELECT new org.thingsboard.server.dao.model.sql.DeviceInfoEntity(d, c.title, c.additionalInfo) " +

@@ -24,7 +24,6 @@ import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.device.DeviceCredentialsDao;
 import org.thingsboard.server.dao.device.DeviceCredentialsDao;
 import org.thingsboard.server.dao.model.sql.DeviceCredentialsEntity;
 import org.thingsboard.server.dao.model.sql.DeviceCredentialsEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.UUID;
 import java.util.UUID;
 
 
@@ -32,7 +31,6 @@ import java.util.UUID;
  * Created by Valerii Sosliuk on 5/6/2017.
  * Created by Valerii Sosliuk on 5/6/2017.
  */
  */
 @Component
 @Component
-@SqlDao
 public class JpaDeviceCredentialsDao extends JpaAbstractDao<DeviceCredentialsEntity, DeviceCredentials> implements DeviceCredentialsDao {
 public class JpaDeviceCredentialsDao extends JpaAbstractDao<DeviceCredentialsEntity, DeviceCredentials> implements DeviceCredentialsDao {
 
 
     @Autowired
     @Autowired

@@ -32,7 +32,6 @@ import org.thingsboard.server.dao.device.DeviceDao;
 import org.thingsboard.server.dao.model.sql.DeviceEntity;
 import org.thingsboard.server.dao.model.sql.DeviceEntity;
 import org.thingsboard.server.dao.model.sql.DeviceInfoEntity;
 import org.thingsboard.server.dao.model.sql.DeviceInfoEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.ArrayList;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Collections;
@@ -45,7 +44,6 @@ import java.util.UUID;
  * Created by Valerii Sosliuk on 5/6/2017.
  * Created by Valerii Sosliuk on 5/6/2017.
  */
  */
 @Component
 @Component
-@SqlDao
 public class JpaDeviceDao extends JpaAbstractSearchTextDao<DeviceEntity, Device> implements DeviceDao {
 public class JpaDeviceDao extends JpaAbstractSearchTextDao<DeviceEntity, Device> implements DeviceDao {
 
 
     @Autowired
     @Autowired

@@ -22,7 +22,6 @@ import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.query.Param;
 import org.springframework.data.repository.query.Param;
 import org.thingsboard.server.dao.model.sql.EntityViewEntity;
 import org.thingsboard.server.dao.model.sql.EntityViewEntity;
 import org.thingsboard.server.dao.model.sql.EntityViewInfoEntity;
 import org.thingsboard.server.dao.model.sql.EntityViewInfoEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.List;
 import java.util.List;
 import java.util.UUID;
 import java.util.UUID;
@@ -30,7 +29,6 @@ import java.util.UUID;
 /**
 /**
  * Created by Victor Basanets on 8/31/2017.
  * Created by Victor Basanets on 8/31/2017.
  */
  */
-@SqlDao
 public interface EntityViewRepository extends PagingAndSortingRepository<EntityViewEntity, UUID> {
 public interface EntityViewRepository extends PagingAndSortingRepository<EntityViewEntity, UUID> {
 
 
     @Query("SELECT new org.thingsboard.server.dao.model.sql.EntityViewInfoEntity(e, c.title, c.additionalInfo) " +
     @Query("SELECT new org.thingsboard.server.dao.model.sql.EntityViewInfoEntity(e, c.title, c.additionalInfo) " +

@@ -31,7 +31,6 @@ import org.thingsboard.server.dao.entityview.EntityViewDao;
 import org.thingsboard.server.dao.model.sql.EntityViewEntity;
 import org.thingsboard.server.dao.model.sql.EntityViewEntity;
 import org.thingsboard.server.dao.model.sql.EntityViewInfoEntity;
 import org.thingsboard.server.dao.model.sql.EntityViewInfoEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.ArrayList;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Collections;
@@ -44,7 +43,6 @@ import java.util.UUID;
  * Created by Victor Basanets on 8/31/2017.
  * Created by Victor Basanets on 8/31/2017.
  */
  */
 @Component
 @Component
-@SqlDao
 public class JpaEntityViewDao extends JpaAbstractSearchTextDao<EntityViewEntity, EntityView>
 public class JpaEntityViewDao extends JpaAbstractSearchTextDao<EntityViewEntity, EntityView>
         implements EntityViewDao {
         implements EntityViewDao {
 
 

@@ -22,7 +22,6 @@ import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.query.Param;
 import org.springframework.data.repository.query.Param;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.dao.model.sql.EventEntity;
 import org.thingsboard.server.dao.model.sql.EventEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.List;
 import java.util.List;
 import java.util.UUID;
 import java.util.UUID;
@@ -30,7 +29,6 @@ import java.util.UUID;
 /**
 /**
  * Created by Valerii Sosliuk on 5/3/2017.
  * Created by Valerii Sosliuk on 5/3/2017.
  */
  */
-@SqlDao
 public interface EventRepository extends PagingAndSortingRepository<EventEntity, UUID> {
 public interface EventRepository extends PagingAndSortingRepository<EventEntity, UUID> {
 
 
     EventEntity findByTenantIdAndEntityTypeAndEntityIdAndEventTypeAndEventUid(UUID tenantId,
     EventEntity findByTenantIdAndEntityTypeAndEntityIdAndEventTypeAndEventUid(UUID tenantId,

@@ -18,11 +18,9 @@ package org.thingsboard.server.dao.sql.event;
 import org.springframework.stereotype.Repository;
 import org.springframework.stereotype.Repository;
 import org.thingsboard.server.dao.model.sql.EventEntity;
 import org.thingsboard.server.dao.model.sql.EventEntity;
 import org.thingsboard.server.dao.util.HsqlDao;
 import org.thingsboard.server.dao.util.HsqlDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import javax.persistence.Query;
 import javax.persistence.Query;
 
 
-@SqlDao
 @HsqlDao
 @HsqlDao
 @Repository
 @Repository
 public class HsqlEventInsertRepository extends AbstractEventInsertRepository {
 public class HsqlEventInsertRepository extends AbstractEventInsertRepository {

@@ -21,7 +21,6 @@ import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.PageRequest;
-import org.springframework.data.jpa.domain.Specification;
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.Event;
 import org.thingsboard.server.common.data.Event;
@@ -34,10 +33,7 @@ import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.event.EventDao;
 import org.thingsboard.server.dao.event.EventDao;
 import org.thingsboard.server.dao.model.sql.EventEntity;
 import org.thingsboard.server.dao.model.sql.EventEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
-import javax.persistence.criteria.Predicate;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.List;
 import java.util.Objects;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.Optional;
@@ -50,7 +46,6 @@ import static org.thingsboard.server.dao.model.ModelConstants.NULL_UUID;
  */
  */
 @Slf4j
 @Slf4j
 @Component
 @Component
-@SqlDao
 public class JpaBaseEventDao extends JpaAbstractDao<EventEntity, Event> implements EventDao {
 public class JpaBaseEventDao extends JpaAbstractDao<EventEntity, Event> implements EventDao {
 
 
     private final UUID systemTenantId = NULL_UUID;
     private final UUID systemTenantId = NULL_UUID;

@@ -19,10 +19,8 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Repository;
 import org.springframework.stereotype.Repository;
 import org.thingsboard.server.dao.model.sql.EventEntity;
 import org.thingsboard.server.dao.model.sql.EventEntity;
 import org.thingsboard.server.dao.util.PsqlDao;
 import org.thingsboard.server.dao.util.PsqlDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 @Slf4j
 @Slf4j
-@SqlDao
 @PsqlDao
 @PsqlDao
 @Repository
 @Repository
 public class PsqlEventInsertRepository extends AbstractEventInsertRepository {
 public class PsqlEventInsertRepository extends AbstractEventInsertRepository {

@@ -39,7 +39,6 @@ import org.thingsboard.server.common.data.query.EntityDataSortOrder;
 import org.thingsboard.server.common.data.query.EntityKey;
 import org.thingsboard.server.common.data.query.EntityKey;
 import org.thingsboard.server.common.data.query.EntityKeyType;
 import org.thingsboard.server.common.data.query.EntityKeyType;
 import org.thingsboard.server.dao.model.ModelConstants;
 import org.thingsboard.server.dao.model.ModelConstants;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.ArrayList;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Arrays;
@@ -52,7 +51,6 @@ import java.util.Objects;
 import java.util.Set;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Collectors;
 
 
-@SqlDao
 @Repository
 @Repository
 @Slf4j
 @Slf4j
 public class DefaultAlarmQueryRepository implements AlarmQueryRepository {
 public class DefaultAlarmQueryRepository implements AlarmQueryRepository {

@@ -50,7 +50,6 @@ import org.thingsboard.server.common.data.query.RelationsQueryFilter;
 import org.thingsboard.server.common.data.query.SingleEntityFilter;
 import org.thingsboard.server.common.data.query.SingleEntityFilter;
 import org.thingsboard.server.common.data.relation.EntitySearchDirection;
 import org.thingsboard.server.common.data.relation.EntitySearchDirection;
 import org.thingsboard.server.common.data.relation.EntityTypeFilter;
 import org.thingsboard.server.common.data.relation.EntityTypeFilter;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.Arrays;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Collections;
@@ -61,7 +60,6 @@ import java.util.Optional;
 import java.util.UUID;
 import java.util.UUID;
 import java.util.stream.Collectors;
 import java.util.stream.Collectors;
 
 
-@SqlDao
 @Repository
 @Repository
 @Slf4j
 @Slf4j
 public class DefaultEntityQueryRepository implements EntityQueryRepository {
 public class DefaultEntityQueryRepository implements EntityQueryRepository {

@@ -24,10 +24,8 @@ import org.thingsboard.server.common.data.query.EntityCountQuery;
 import org.thingsboard.server.common.data.query.EntityData;
 import org.thingsboard.server.common.data.query.EntityData;
 import org.thingsboard.server.common.data.query.EntityDataQuery;
 import org.thingsboard.server.common.data.query.EntityDataQuery;
 import org.thingsboard.server.dao.entity.EntityQueryDao;
 import org.thingsboard.server.dao.entity.EntityQueryDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 @Component
 @Component
-@SqlDao
 public class JpaEntityQueryDao implements EntityQueryDao {
 public class JpaEntityQueryDao implements EntityQueryDao {
 
 
     @Autowired
     @Autowired

@@ -20,12 +20,10 @@ import org.springframework.transaction.annotation.Transactional;
 import org.thingsboard.server.dao.model.sql.RelationCompositeKey;
 import org.thingsboard.server.dao.model.sql.RelationCompositeKey;
 import org.thingsboard.server.dao.model.sql.RelationEntity;
 import org.thingsboard.server.dao.model.sql.RelationEntity;
 import org.thingsboard.server.dao.util.HsqlDao;
 import org.thingsboard.server.dao.util.HsqlDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import javax.persistence.Query;
 import javax.persistence.Query;
 
 
 @HsqlDao
 @HsqlDao
-@SqlDao
 @Repository
 @Repository
 @Transactional
 @Transactional
 public class HsqlRelationInsertRepository extends AbstractRelationInsertRepository implements RelationInsertRepository {
 public class HsqlRelationInsertRepository extends AbstractRelationInsertRepository implements RelationInsertRepository {

@@ -30,7 +30,6 @@ import org.thingsboard.server.dao.model.sql.RelationCompositeKey;
 import org.thingsboard.server.dao.model.sql.RelationEntity;
 import org.thingsboard.server.dao.model.sql.RelationEntity;
 import org.thingsboard.server.dao.relation.RelationDao;
 import org.thingsboard.server.dao.relation.RelationDao;
 import org.thingsboard.server.dao.sql.JpaAbstractDaoListeningExecutorService;
 import org.thingsboard.server.dao.sql.JpaAbstractDaoListeningExecutorService;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import javax.persistence.criteria.Predicate;
 import javax.persistence.criteria.Predicate;
 import java.util.ArrayList;
 import java.util.ArrayList;
@@ -41,7 +40,6 @@ import java.util.List;
  */
  */
 @Slf4j
 @Slf4j
 @Component
 @Component
-@SqlDao
 public class JpaRelationDao extends JpaAbstractDaoListeningExecutorService implements RelationDao {
 public class JpaRelationDao extends JpaAbstractDaoListeningExecutorService implements RelationDao {
 
 
     @Autowired
     @Autowired

@@ -19,10 +19,8 @@ import org.springframework.stereotype.Repository;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.annotation.Transactional;
 import org.thingsboard.server.dao.model.sql.RelationEntity;
 import org.thingsboard.server.dao.model.sql.RelationEntity;
 import org.thingsboard.server.dao.util.PsqlDao;
 import org.thingsboard.server.dao.util.PsqlDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 @PsqlDao
 @PsqlDao
-@SqlDao
 @Repository
 @Repository
 @Transactional
 @Transactional
 public class PsqlRelationInsertRepository extends AbstractRelationInsertRepository implements RelationInsertRepository {
 public class PsqlRelationInsertRepository extends AbstractRelationInsertRepository implements RelationInsertRepository {

@@ -20,12 +20,10 @@ import org.springframework.data.repository.CrudRepository;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.annotation.Transactional;
 import org.thingsboard.server.dao.model.sql.RelationCompositeKey;
 import org.thingsboard.server.dao.model.sql.RelationCompositeKey;
 import org.thingsboard.server.dao.model.sql.RelationEntity;
 import org.thingsboard.server.dao.model.sql.RelationEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.List;
 import java.util.List;
 import java.util.UUID;
 import java.util.UUID;
 
 
-@SqlDao
 public interface RelationRepository
 public interface RelationRepository
         extends CrudRepository<RelationEntity, RelationCompositeKey>, JpaSpecificationExecutor<RelationEntity> {
         extends CrudRepository<RelationEntity, RelationCompositeKey>, JpaSpecificationExecutor<RelationEntity> {
 
 

@@ -26,14 +26,12 @@ import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.model.sql.RuleChainEntity;
 import org.thingsboard.server.dao.model.sql.RuleChainEntity;
 import org.thingsboard.server.dao.rule.RuleChainDao;
 import org.thingsboard.server.dao.rule.RuleChainDao;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.Objects;
 import java.util.Objects;
 import java.util.UUID;
 import java.util.UUID;
 
 
 @Slf4j
 @Slf4j
 @Component
 @Component
-@SqlDao
 public class JpaRuleChainDao extends JpaAbstractSearchTextDao<RuleChainEntity, RuleChain> implements RuleChainDao {
 public class JpaRuleChainDao extends JpaAbstractSearchTextDao<RuleChainEntity, RuleChain> implements RuleChainDao {
 
 
     @Autowired
     @Autowired

@@ -23,11 +23,9 @@ import org.thingsboard.server.common.data.rule.RuleNode;
 import org.thingsboard.server.dao.model.sql.RuleNodeEntity;
 import org.thingsboard.server.dao.model.sql.RuleNodeEntity;
 import org.thingsboard.server.dao.rule.RuleNodeDao;
 import org.thingsboard.server.dao.rule.RuleNodeDao;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 @Slf4j
 @Slf4j
 @Component
 @Component
-@SqlDao
 public class JpaRuleNodeDao extends JpaAbstractSearchTextDao<RuleNodeEntity, RuleNode> implements RuleNodeDao {
 public class JpaRuleNodeDao extends JpaAbstractSearchTextDao<RuleNodeEntity, RuleNode> implements RuleNodeDao {
 
 
     @Autowired
     @Autowired

@@ -21,11 +21,9 @@ import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.query.Param;
 import org.springframework.data.repository.query.Param;
 import org.thingsboard.server.dao.model.sql.RuleChainEntity;
 import org.thingsboard.server.dao.model.sql.RuleChainEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.UUID;
 import java.util.UUID;
 
 
-@SqlDao
 public interface RuleChainRepository extends PagingAndSortingRepository<RuleChainEntity, UUID> {
 public interface RuleChainRepository extends PagingAndSortingRepository<RuleChainEntity, UUID> {
 
 
     @Query("SELECT rc FROM RuleChainEntity rc WHERE rc.tenantId = :tenantId " +
     @Query("SELECT rc FROM RuleChainEntity rc WHERE rc.tenantId = :tenantId " +

@@ -17,9 +17,7 @@ package org.thingsboard.server.dao.sql.rule;
 
 
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.data.repository.CrudRepository;
 import org.thingsboard.server.dao.model.sql.RuleNodeEntity;
 import org.thingsboard.server.dao.model.sql.RuleNodeEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
-@SqlDao
 public interface RuleNodeRepository extends CrudRepository<RuleNodeEntity, String> {
 public interface RuleNodeRepository extends CrudRepository<RuleNodeEntity, String> {
 
 
 }
 }

@@ -25,13 +25,11 @@ import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.model.sql.AdminSettingsEntity;
 import org.thingsboard.server.dao.model.sql.AdminSettingsEntity;
 import org.thingsboard.server.dao.settings.AdminSettingsDao;
 import org.thingsboard.server.dao.settings.AdminSettingsDao;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.UUID;
 import java.util.UUID;
 
 
 @Component
 @Component
 @Slf4j
 @Slf4j
-@SqlDao
 public class JpaAdminSettingsDao extends JpaAbstractDao<AdminSettingsEntity, AdminSettings> implements AdminSettingsDao {
 public class JpaAdminSettingsDao extends JpaAbstractDao<AdminSettingsEntity, AdminSettings> implements AdminSettingsDao {
 
 
     @Autowired
     @Autowired

@@ -26,7 +26,6 @@ import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.model.sql.TenantEntity;
 import org.thingsboard.server.dao.model.sql.TenantEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
 import org.thingsboard.server.dao.tenant.TenantDao;
 import org.thingsboard.server.dao.tenant.TenantDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.Objects;
 import java.util.Objects;
 import java.util.UUID;
 import java.util.UUID;
@@ -36,7 +35,6 @@ import java.util.UUID;
  * Created by Valerii Sosliuk on 4/30/2017.
  * Created by Valerii Sosliuk on 4/30/2017.
  */
  */
 @Component
 @Component
-@SqlDao
 public class JpaTenantDao extends JpaAbstractSearchTextDao<TenantEntity, Tenant> implements TenantDao {
 public class JpaTenantDao extends JpaAbstractSearchTextDao<TenantEntity, Tenant> implements TenantDao {
 
 
     @Autowired
     @Autowired

@@ -21,14 +21,12 @@ import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.query.Param;
 import org.springframework.data.repository.query.Param;
 import org.thingsboard.server.dao.model.sql.TenantEntity;
 import org.thingsboard.server.dao.model.sql.TenantEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.UUID;
 import java.util.UUID;
 
 
 /**
 /**
  * Created by Valerii Sosliuk on 4/30/2017.
  * Created by Valerii Sosliuk on 4/30/2017.
  */
  */
-@SqlDao
 public interface TenantRepository extends PagingAndSortingRepository<TenantEntity, UUID> {
 public interface TenantRepository extends PagingAndSortingRepository<TenantEntity, UUID> {
 
 
     @Query("SELECT t FROM TenantEntity t WHERE t.region = :region " +
     @Query("SELECT t FROM TenantEntity t WHERE t.region = :region " +

@@ -24,7 +24,6 @@ import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.model.sql.UserCredentialsEntity;
 import org.thingsboard.server.dao.model.sql.UserCredentialsEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
 import org.thingsboard.server.dao.user.UserCredentialsDao;
 import org.thingsboard.server.dao.user.UserCredentialsDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.UUID;
 import java.util.UUID;
 
 
@@ -32,7 +31,6 @@ import java.util.UUID;
  * Created by Valerii Sosliuk on 4/22/2017.
  * Created by Valerii Sosliuk on 4/22/2017.
  */
  */
 @Component
 @Component
-@SqlDao
 public class JpaUserCredentialsDao extends JpaAbstractDao<UserCredentialsEntity, UserCredentials> implements UserCredentialsDao {
 public class JpaUserCredentialsDao extends JpaAbstractDao<UserCredentialsEntity, UserCredentials> implements UserCredentialsDao {
 
 
     @Autowired
     @Autowired

@@ -27,7 +27,6 @@ import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.model.sql.UserEntity;
 import org.thingsboard.server.dao.model.sql.UserEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
 import org.thingsboard.server.dao.user.UserDao;
 import org.thingsboard.server.dao.user.UserDao;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.Objects;
 import java.util.Objects;
 import java.util.UUID;
 import java.util.UUID;
@@ -38,7 +37,6 @@ import static org.thingsboard.server.dao.model.ModelConstants.NULL_UUID;
  * @author Valerii Sosliuk
  * @author Valerii Sosliuk
  */
  */
 @Component
 @Component
-@SqlDao
 public class JpaUserDao extends JpaAbstractSearchTextDao<UserEntity, User> implements UserDao {
 public class JpaUserDao extends JpaAbstractSearchTextDao<UserEntity, User> implements UserDao {
 
 
     @Autowired
     @Autowired

@@ -17,14 +17,12 @@ package org.thingsboard.server.dao.sql.user;
 
 
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.data.repository.CrudRepository;
 import org.thingsboard.server.dao.model.sql.UserCredentialsEntity;
 import org.thingsboard.server.dao.model.sql.UserCredentialsEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.UUID;
 import java.util.UUID;
 
 
 /**
 /**
  * Created by Valerii Sosliuk on 4/22/2017.
  * Created by Valerii Sosliuk on 4/22/2017.
  */
  */
-@SqlDao
 public interface UserCredentialsRepository extends CrudRepository<UserCredentialsEntity, UUID> {
 public interface UserCredentialsRepository extends CrudRepository<UserCredentialsEntity, UUID> {
 
 
     UserCredentialsEntity findByUserId(UUID userId);
     UserCredentialsEntity findByUserId(UUID userId);

@@ -22,14 +22,12 @@ import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.query.Param;
 import org.springframework.data.repository.query.Param;
 import org.thingsboard.server.common.data.security.Authority;
 import org.thingsboard.server.common.data.security.Authority;
 import org.thingsboard.server.dao.model.sql.UserEntity;
 import org.thingsboard.server.dao.model.sql.UserEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.UUID;
 import java.util.UUID;
 
 
 /**
 /**
  * @author Valerii Sosliuk
  * @author Valerii Sosliuk
  */
  */
-@SqlDao
 public interface UserRepository extends PagingAndSortingRepository<UserEntity, UUID> {
 public interface UserRepository extends PagingAndSortingRepository<UserEntity, UUID> {
 
 
     UserEntity findByEmail(String email);
     UserEntity findByEmail(String email);

@@ -22,7 +22,6 @@ import org.thingsboard.server.common.data.widget.WidgetType;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.model.sql.WidgetTypeEntity;
 import org.thingsboard.server.dao.model.sql.WidgetTypeEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
-import org.thingsboard.server.dao.util.SqlDao;
 import org.thingsboard.server.dao.widget.WidgetTypeDao;
 import org.thingsboard.server.dao.widget.WidgetTypeDao;
 
 
 import java.util.List;
 import java.util.List;
@@ -32,7 +31,6 @@ import java.util.UUID;
  * Created by Valerii Sosliuk on 4/29/2017.
  * Created by Valerii Sosliuk on 4/29/2017.
  */
  */
 @Component
 @Component
-@SqlDao
 public class JpaWidgetTypeDao extends JpaAbstractDao<WidgetTypeEntity, WidgetType> implements WidgetTypeDao {
 public class JpaWidgetTypeDao extends JpaAbstractDao<WidgetTypeEntity, WidgetType> implements WidgetTypeDao {
 
 
     @Autowired
     @Autowired

@@ -25,7 +25,6 @@ import org.thingsboard.server.common.data.widget.WidgetsBundle;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.model.sql.WidgetsBundleEntity;
 import org.thingsboard.server.dao.model.sql.WidgetsBundleEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
 import org.thingsboard.server.dao.sql.JpaAbstractSearchTextDao;
-import org.thingsboard.server.dao.util.SqlDao;
 import org.thingsboard.server.dao.widget.WidgetsBundleDao;
 import org.thingsboard.server.dao.widget.WidgetsBundleDao;
 
 
 import java.util.Objects;
 import java.util.Objects;
@@ -37,7 +36,6 @@ import static org.thingsboard.server.dao.model.ModelConstants.NULL_UUID;
  * Created by Valerii Sosliuk on 4/23/2017.
  * Created by Valerii Sosliuk on 4/23/2017.
  */
  */
 @Component
 @Component
-@SqlDao
 public class JpaWidgetsBundleDao extends JpaAbstractSearchTextDao<WidgetsBundleEntity, WidgetsBundle> implements WidgetsBundleDao {
 public class JpaWidgetsBundleDao extends JpaAbstractSearchTextDao<WidgetsBundleEntity, WidgetsBundle> implements WidgetsBundleDao {
 
 
     @Autowired
     @Autowired

@@ -17,7 +17,6 @@ package org.thingsboard.server.dao.sql.widget;
 
 
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.data.repository.CrudRepository;
 import org.thingsboard.server.dao.model.sql.WidgetTypeEntity;
 import org.thingsboard.server.dao.model.sql.WidgetTypeEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.List;
 import java.util.List;
 import java.util.UUID;
 import java.util.UUID;
@@ -25,7 +24,6 @@ import java.util.UUID;
 /**
 /**
  * Created by Valerii Sosliuk on 4/29/2017.
  * Created by Valerii Sosliuk on 4/29/2017.
  */
  */
-@SqlDao
 public interface WidgetTypeRepository extends CrudRepository<WidgetTypeEntity, UUID> {
 public interface WidgetTypeRepository extends CrudRepository<WidgetTypeEntity, UUID> {
 
 
     List<WidgetTypeEntity> findByTenantIdAndBundleAlias(UUID tenantId, String bundleAlias);
     List<WidgetTypeEntity> findByTenantIdAndBundleAlias(UUID tenantId, String bundleAlias);

@@ -21,14 +21,12 @@ import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.data.repository.query.Param;
 import org.springframework.data.repository.query.Param;
 import org.thingsboard.server.dao.model.sql.WidgetsBundleEntity;
 import org.thingsboard.server.dao.model.sql.WidgetsBundleEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.UUID;
 import java.util.UUID;
 
 
 /**
 /**
  * Created by Valerii Sosliuk on 4/23/2017.
  * Created by Valerii Sosliuk on 4/23/2017.
  */
  */
-@SqlDao
 public interface WidgetsBundleRepository extends PagingAndSortingRepository<WidgetsBundleEntity, UUID> {
 public interface WidgetsBundleRepository extends PagingAndSortingRepository<WidgetsBundleEntity, UUID> {
 
 
     WidgetsBundleEntity findWidgetsBundleByTenantIdAndAlias(UUID tenantId, String alias);
     WidgetsBundleEntity findWidgetsBundleByTenantIdAndAlias(UUID tenantId, String alias);

@@ -17,7 +17,6 @@ package org.thingsboard.server.dao.sqlts;
 
 
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.ListeningExecutorService;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.common.util.concurrent.SettableFuture;
 import com.google.common.util.concurrent.SettableFuture;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
@@ -33,7 +32,6 @@ import org.thingsboard.server.common.data.kv.TsKvEntry;
 import org.thingsboard.server.common.stats.StatsFactory;
 import org.thingsboard.server.common.stats.StatsFactory;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.model.sqlts.ts.TsKvEntity;
 import org.thingsboard.server.dao.model.sqlts.ts.TsKvEntity;
-import org.thingsboard.server.dao.sql.TbSqlBlockingQueue;
 import org.thingsboard.server.dao.sql.TbSqlBlockingQueueParams;
 import org.thingsboard.server.dao.sql.TbSqlBlockingQueueParams;
 import org.thingsboard.server.dao.sql.TbSqlBlockingQueueWrapper;
 import org.thingsboard.server.dao.sql.TbSqlBlockingQueueWrapper;
 import org.thingsboard.server.dao.sqlts.insert.InsertTsRepository;
 import org.thingsboard.server.dao.sqlts.insert.InsertTsRepository;
@@ -64,7 +62,6 @@ public abstract class AbstractChunkedAggregationTimeseriesDao extends AbstractSq
 
 
     @PostConstruct
     @PostConstruct
     protected void init() {
     protected void init() {
-        super.init();
         TbSqlBlockingQueueParams tsParams = TbSqlBlockingQueueParams.builder()
         TbSqlBlockingQueueParams tsParams = TbSqlBlockingQueueParams.builder()
                 .logName("TS")
                 .logName("TS")
                 .batchSize(tsBatchSize)
                 .batchSize(tsBatchSize)
@@ -80,7 +77,6 @@ public abstract class AbstractChunkedAggregationTimeseriesDao extends AbstractSq
 
 
     @PreDestroy
     @PreDestroy
     protected void destroy() {
     protected void destroy() {
-        super.destroy();
         if (tsQueue != null) {
         if (tsQueue != null) {
             tsQueue.destroy();
             tsQueue.destroy();
         }
         }
@@ -99,26 +95,6 @@ public abstract class AbstractChunkedAggregationTimeseriesDao extends AbstractSq
     }
     }
 
 
     @Override
     @Override
-    public ListenableFuture<Void> saveLatest(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry) {
-        return getSaveLatestFuture(entityId, tsKvEntry);
-    }
-
-    @Override
-    public ListenableFuture<Void> removeLatest(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
-        return getRemoveLatestFuture(entityId, query);
-    }
-
-    @Override
-    public ListenableFuture<TsKvEntry> findLatest(TenantId tenantId, EntityId entityId, String key) {
-        return getFindLatestFuture(entityId, key);
-    }
-
-    @Override
-    public ListenableFuture<List<TsKvEntry>> findAllLatest(TenantId tenantId, EntityId entityId) {
-        return getFindAllLatestFuture(entityId);
-    }
-
-    @Override
     public ListenableFuture<Void> savePartition(TenantId tenantId, EntityId entityId, long tsKvEntryTs, String key, long ttl) {
     public ListenableFuture<Void> savePartition(TenantId tenantId, EntityId entityId, long tsKvEntryTs, String key, long ttl) {
         return Futures.immediateFuture(null);
         return Futures.immediateFuture(null);
     }
     }
@@ -134,7 +110,7 @@ public abstract class AbstractChunkedAggregationTimeseriesDao extends AbstractSq
     }
     }
 
 
     @Override
     @Override
-    protected ListenableFuture<List<TsKvEntry>> findAllAsync(EntityId entityId, ReadTsKvQuery query) {
+    public ListenableFuture<List<TsKvEntry>> findAllAsync(TenantId tenantId, EntityId entityId, ReadTsKvQuery query) {
         if (query.getAggregation() == Aggregation.NONE) {
         if (query.getAggregation() == Aggregation.NONE) {
             return findAllAsyncWithLimit(entityId, query);
             return findAllAsyncWithLimit(entityId, query);
         } else {
         } else {
@@ -151,8 +127,7 @@ public abstract class AbstractChunkedAggregationTimeseriesDao extends AbstractSq
         }
         }
     }
     }
 
 
-    @Override
-    protected ListenableFuture<List<TsKvEntry>> findAllAsyncWithLimit(EntityId entityId, ReadTsKvQuery query) {
+    private ListenableFuture<List<TsKvEntry>> findAllAsyncWithLimit(EntityId entityId, ReadTsKvQuery query) {
         Integer keyId = getOrSaveKeyId(query.getKey());
         Integer keyId = getOrSaveKeyId(query.getKey());
         List<TsKvEntity> tsKvEntities = tsKvRepository.findAllWithLimit(
         List<TsKvEntity> tsKvEntities = tsKvRepository.findAllWithLimit(
                 entityId.getId(),
                 entityId.getId(),

@@ -16,96 +16,28 @@
 package org.thingsboard.server.dao.sqlts;
 package org.thingsboard.server.dao.sqlts;
 
 
 import com.google.common.base.Function;
 import com.google.common.base.Function;
-import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.MoreExecutors;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
-import org.hibernate.exception.ConstraintViolationException;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.beans.factory.annotation.Value;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
-import org.thingsboard.server.common.data.kv.Aggregation;
-import org.thingsboard.server.common.data.kv.BaseReadTsKvQuery;
-import org.thingsboard.server.common.data.kv.BasicTsKvEntry;
-import org.thingsboard.server.common.data.kv.DeleteTsKvQuery;
 import org.thingsboard.server.common.data.kv.ReadTsKvQuery;
 import org.thingsboard.server.common.data.kv.ReadTsKvQuery;
-import org.thingsboard.server.common.data.kv.StringDataEntry;
 import org.thingsboard.server.common.data.kv.TsKvEntry;
 import org.thingsboard.server.common.data.kv.TsKvEntry;
-import org.thingsboard.server.common.stats.StatsFactory;
-import org.thingsboard.server.dao.DaoUtil;
-import org.thingsboard.server.dao.model.sqlts.dictionary.TsKvDictionary;
-import org.thingsboard.server.dao.model.sqlts.dictionary.TsKvDictionaryCompositeKey;
-import org.thingsboard.server.dao.model.sqlts.latest.TsKvLatestCompositeKey;
-import org.thingsboard.server.dao.model.sqlts.latest.TsKvLatestEntity;
-import org.thingsboard.server.dao.sql.JpaAbstractDaoListeningExecutorService;
 import org.thingsboard.server.dao.sql.ScheduledLogExecutorComponent;
 import org.thingsboard.server.dao.sql.ScheduledLogExecutorComponent;
-import org.thingsboard.server.dao.sql.TbSqlBlockingQueueParams;
-import org.thingsboard.server.dao.sql.TbSqlBlockingQueueWrapper;
-import org.thingsboard.server.dao.sqlts.dictionary.TsKvDictionaryRepository;
-import org.thingsboard.server.dao.sqlts.insert.latest.InsertLatestTsRepository;
-import org.thingsboard.server.dao.sqlts.latest.SearchTsKvLatestRepository;
-import org.thingsboard.server.dao.sqlts.latest.TsKvLatestRepository;
-import org.thingsboard.server.dao.timeseries.SimpleListenableFuture;
 
 
 import javax.annotation.Nullable;
 import javax.annotation.Nullable;
-import javax.annotation.PostConstruct;
-import javax.annotation.PreDestroy;
-import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 import java.util.List;
-import java.util.Map;
 import java.util.Objects;
 import java.util.Objects;
-import java.util.Optional;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.locks.ReentrantLock;
 import java.util.stream.Collectors;
 import java.util.stream.Collectors;
 
 
 @Slf4j
 @Slf4j
-public abstract class AbstractSqlTimeseriesDao extends JpaAbstractDaoListeningExecutorService {
-
-    private static final String DESC_ORDER = "DESC";
-
-    private final ConcurrentMap<String, Integer> tsKvDictionaryMap = new ConcurrentHashMap<>();
-
-    private static final ReentrantLock tsCreationLock = new ReentrantLock();
-
-    @Autowired
-    private TsKvLatestRepository tsKvLatestRepository;
-
-    @Autowired
-    private SearchTsKvLatestRepository searchTsKvLatestRepository;
-
-    @Autowired
-    private InsertLatestTsRepository insertLatestTsRepository;
-
-    @Autowired
-    private TsKvDictionaryRepository dictionaryRepository;
-
-    private TbSqlBlockingQueueWrapper<TsKvLatestEntity> tsLatestQueue;
-
-    @Value("${sql.ts_latest.batch_size:1000}")
-    private int tsLatestBatchSize;
-
-    @Value("${sql.ts_latest.batch_max_delay:100}")
-    private long tsLatestMaxDelay;
-
-    @Value("${sql.ts_latest.stats_print_interval_ms:1000}")
-    private long tsLatestStatsPrintIntervalMs;
-
-    @Value("${sql.ts_latest.batch_threads:4}")
-    private int tsLatestBatchThreads;
+public abstract class AbstractSqlTimeseriesDao extends BaseAbstractSqlTimeseriesDao implements AggregationTimeseriesDao {
 
 
     @Autowired
     @Autowired
     protected ScheduledLogExecutorComponent logExecutor;
     protected ScheduledLogExecutorComponent logExecutor;
 
 
-    @Autowired
-    private StatsFactory statsFactory;
-
     @Value("${sql.ts.batch_size:1000}")
     @Value("${sql.ts.batch_size:1000}")
     protected int tsBatchSize;
     protected int tsBatchSize;
 
 
@@ -121,44 +53,10 @@ public abstract class AbstractSqlTimeseriesDao extends JpaAbstractDaoListeningEx
     @Value("${sql.timescale.batch_threads:4}")
     @Value("${sql.timescale.batch_threads:4}")
     protected int timescaleBatchThreads;
     protected int timescaleBatchThreads;
 
 
-    @PostConstruct
-    protected void init() {
-        TbSqlBlockingQueueParams tsLatestParams = TbSqlBlockingQueueParams.builder()
-                .logName("TS Latest")
-                .batchSize(tsLatestBatchSize)
-                .maxDelay(tsLatestMaxDelay)
-                .statsPrintIntervalMs(tsLatestStatsPrintIntervalMs)
-                .statsNamePrefix("ts.latest")
-                .build();
-
-        java.util.function.Function<TsKvLatestEntity, Integer> hashcodeFunction = entity -> entity.getEntityId().hashCode();
-        tsLatestQueue = new TbSqlBlockingQueueWrapper<>(tsLatestParams, hashcodeFunction, tsLatestBatchThreads, statsFactory);
-
-        tsLatestQueue.init(logExecutor, v -> {
-            Map<TsKey, TsKvLatestEntity> trueLatest = new HashMap<>();
-            v.forEach(ts -> {
-                TsKey key = new TsKey(ts.getEntityId(), ts.getKey());
-                TsKvLatestEntity old = trueLatest.get(key);
-                if (old == null || old.getTs() < ts.getTs()) {
-                    trueLatest.put(key, ts);
-                }
-            });
-            List<TsKvLatestEntity> latestEntities = new ArrayList<>(trueLatest.values());
-            insertLatestTsRepository.saveOrUpdate(latestEntities);
-        });
-    }
-
-    @PreDestroy
-    protected void destroy() {
-        if (tsLatestQueue != null) {
-            tsLatestQueue.destroy();
-        }
-    }
-
     protected ListenableFuture<List<TsKvEntry>> processFindAllAsync(TenantId tenantId, EntityId entityId, List<ReadTsKvQuery> queries) {
     protected ListenableFuture<List<TsKvEntry>> processFindAllAsync(TenantId tenantId, EntityId entityId, List<ReadTsKvQuery> queries) {
         List<ListenableFuture<List<TsKvEntry>>> futures = queries
         List<ListenableFuture<List<TsKvEntry>>> futures = queries
                 .stream()
                 .stream()
-                .map(query -> findAllAsync(entityId, query))
+                .map(query -> findAllAsync(tenantId, entityId, query))
                 .collect(Collectors.toList());
                 .collect(Collectors.toList());
         return Futures.transform(Futures.allAsList(futures), new Function<List<List<TsKvEntry>>, List<TsKvEntry>>() {
         return Futures.transform(Futures.allAsList(futures), new Function<List<List<TsKvEntry>>, List<TsKvEntry>>() {
             @Nullable
             @Nullable
@@ -174,168 +72,4 @@ public abstract class AbstractSqlTimeseriesDao extends JpaAbstractDaoListeningEx
             }
             }
         }, service);
         }, service);
     }
     }
-
-    protected abstract ListenableFuture<List<TsKvEntry>> findAllAsync(EntityId entityId, ReadTsKvQuery query);
-
-    protected abstract ListenableFuture<List<TsKvEntry>> findAllAsyncWithLimit(EntityId entityId, ReadTsKvQuery query);
-
-    protected ListenableFuture<List<TsKvEntry>> getTskvEntriesFuture(ListenableFuture<List<Optional<TsKvEntry>>> future) {
-        return Futures.transform(future, new Function<List<Optional<TsKvEntry>>, List<TsKvEntry>>() {
-            @Nullable
-            @Override
-            public List<TsKvEntry> apply(@Nullable List<Optional<TsKvEntry>> results) {
-                if (results == null || results.isEmpty()) {
-                    return null;
-                }
-                return results.stream()
-                        .filter(Optional::isPresent)
-                        .map(Optional::get)
-                        .collect(Collectors.toList());
-            }
-        }, service);
-    }
-
-    protected ListenableFuture<List<TsKvEntry>> findNewLatestEntryFuture(EntityId entityId, DeleteTsKvQuery query) {
-        long startTs = 0;
-        long endTs = query.getStartTs() - 1;
-        ReadTsKvQuery findNewLatestQuery = new BaseReadTsKvQuery(query.getKey(), startTs, endTs, endTs - startTs, 1,
-                Aggregation.NONE, DESC_ORDER);
-        return findAllAsync(entityId, findNewLatestQuery);
-    }
-
-    protected ListenableFuture<TsKvEntry> getFindLatestFuture(EntityId entityId, String key) {
-        TsKvLatestCompositeKey compositeKey =
-                new TsKvLatestCompositeKey(
-                        entityId.getId(),
-                        getOrSaveKeyId(key));
-        Optional<TsKvLatestEntity> entry = tsKvLatestRepository.findById(compositeKey);
-        TsKvEntry result;
-        if (entry.isPresent()) {
-            TsKvLatestEntity tsKvLatestEntity = entry.get();
-            tsKvLatestEntity.setStrKey(key);
-            result = DaoUtil.getData(tsKvLatestEntity);
-        } else {
-            result = new BasicTsKvEntry(System.currentTimeMillis(), new StringDataEntry(key, null));
-        }
-        return Futures.immediateFuture(result);
-    }
-
-    protected ListenableFuture<Void> getRemoveLatestFuture(EntityId entityId, DeleteTsKvQuery query) {
-        ListenableFuture<TsKvEntry> latestFuture = getFindLatestFuture(entityId, query.getKey());
-
-        ListenableFuture<Boolean> booleanFuture = Futures.transform(latestFuture, tsKvEntry -> {
-            long ts = tsKvEntry.getTs();
-            return ts > query.getStartTs() && ts <= query.getEndTs();
-        }, service);
-
-        ListenableFuture<Void> removedLatestFuture = Futures.transformAsync(booleanFuture, isRemove -> {
-            if (isRemove) {
-                TsKvLatestEntity latestEntity = new TsKvLatestEntity();
-                latestEntity.setEntityId(entityId.getId());
-                latestEntity.setKey(getOrSaveKeyId(query.getKey()));
-                return service.submit(() -> {
-                    tsKvLatestRepository.delete(latestEntity);
-                    return null;
-                });
-            }
-            return Futures.immediateFuture(null);
-        }, service);
-
-        final SimpleListenableFuture<Void> resultFuture = new SimpleListenableFuture<>();
-        Futures.addCallback(removedLatestFuture, new FutureCallback<Void>() {
-            @Override
-            public void onSuccess(@Nullable Void result) {
-                if (query.getRewriteLatestIfDeleted()) {
-                    ListenableFuture<Void> savedLatestFuture = Futures.transformAsync(booleanFuture, isRemove -> {
-                        if (isRemove) {
-                            return getNewLatestEntryFuture(entityId, query);
-                        }
-                        return Futures.immediateFuture(null);
-                    }, service);
-
-                    try {
-                        resultFuture.set(savedLatestFuture.get());
-                    } catch (InterruptedException | ExecutionException e) {
-                        log.warn("Could not get latest saved value for [{}], {}", entityId, query.getKey(), e);
-                    }
-                } else {
-                    resultFuture.set(null);
-                }
-            }
-
-            @Override
-            public void onFailure(Throwable t) {
-                log.warn("[{}] Failed to process remove of the latest value", entityId, t);
-            }
-        }, MoreExecutors.directExecutor());
-        return resultFuture;
-    }
-
-    protected ListenableFuture<List<TsKvEntry>> getFindAllLatestFuture(EntityId entityId) {
-        return Futures.immediateFuture(
-                DaoUtil.convertDataList(Lists.newArrayList(
-                        searchTsKvLatestRepository.findAllByEntityId(entityId.getId()))));
-    }
-
-    protected ListenableFuture<Void> getSaveLatestFuture(EntityId entityId, TsKvEntry tsKvEntry) {
-        TsKvLatestEntity latestEntity = new TsKvLatestEntity();
-        latestEntity.setEntityId(entityId.getId());
-        latestEntity.setTs(tsKvEntry.getTs());
-        latestEntity.setKey(getOrSaveKeyId(tsKvEntry.getKey()));
-        latestEntity.setStrValue(tsKvEntry.getStrValue().orElse(null));
-        latestEntity.setDoubleValue(tsKvEntry.getDoubleValue().orElse(null));
-        latestEntity.setLongValue(tsKvEntry.getLongValue().orElse(null));
-        latestEntity.setBooleanValue(tsKvEntry.getBooleanValue().orElse(null));
-        latestEntity.setJsonValue(tsKvEntry.getJsonValue().orElse(null));
-
-        return tsLatestQueue.add(latestEntity);
-    }
-
-    protected Integer getOrSaveKeyId(String strKey) {
-        Integer keyId = tsKvDictionaryMap.get(strKey);
-        if (keyId == null) {
-            Optional<TsKvDictionary> tsKvDictionaryOptional;
-            tsKvDictionaryOptional = dictionaryRepository.findById(new TsKvDictionaryCompositeKey(strKey));
-            if (!tsKvDictionaryOptional.isPresent()) {
-                tsCreationLock.lock();
-                try {
-                    tsKvDictionaryOptional = dictionaryRepository.findById(new TsKvDictionaryCompositeKey(strKey));
-                    if (!tsKvDictionaryOptional.isPresent()) {
-                        TsKvDictionary tsKvDictionary = new TsKvDictionary();
-                        tsKvDictionary.setKey(strKey);
-                        try {
-                            TsKvDictionary saved = dictionaryRepository.save(tsKvDictionary);
-                            tsKvDictionaryMap.put(saved.getKey(), saved.getKeyId());
-                            keyId = saved.getKeyId();
-                        } catch (ConstraintViolationException e) {
-                            tsKvDictionaryOptional = dictionaryRepository.findById(new TsKvDictionaryCompositeKey(strKey));
-                            TsKvDictionary dictionary = tsKvDictionaryOptional.orElseThrow(() -> new RuntimeException("Failed to get TsKvDictionary entity from DB!"));
-                            tsKvDictionaryMap.put(dictionary.getKey(), dictionary.getKeyId());
-                            keyId = dictionary.getKeyId();
-                        }
-                    } else {
-                        keyId = tsKvDictionaryOptional.get().getKeyId();
-                    }
-                } finally {
-                    tsCreationLock.unlock();
-                }
-            } else {
-                keyId = tsKvDictionaryOptional.get().getKeyId();
-                tsKvDictionaryMap.put(strKey, keyId);
-            }
-        }
-        return keyId;
-    }
-
-    private ListenableFuture<Void> getNewLatestEntryFuture(EntityId entityId, DeleteTsKvQuery query) {
-        ListenableFuture<List<TsKvEntry>> future = findNewLatestEntryFuture(entityId, query);
-        return Futures.transformAsync(future, entryList -> {
-            if (entryList.size() == 1) {
-                return getSaveLatestFuture(entityId, entryList.get(0));
-            } else {
-                log.trace("Could not find new latest value for [{}], key - {}", entityId, query.getKey());
-            }
-            return Futures.immediateFuture(null);
-        }, service);
-    }
 }
 }

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.dao.sqlts;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.kv.ReadTsKvQuery;
+import org.thingsboard.server.common.data.kv.TsKvEntry;
+
+import java.util.List;
+
+public interface AggregationTimeseriesDao {
+
+    ListenableFuture<List<TsKvEntry>> findAllAsync(TenantId tenantId, EntityId entityId, ReadTsKvQuery query);
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.dao.sqlts;
+
+import com.google.common.base.Function;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import lombok.extern.slf4j.Slf4j;
+import org.hibernate.exception.ConstraintViolationException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.thingsboard.server.common.data.kv.TsKvEntry;
+import org.thingsboard.server.dao.model.sqlts.dictionary.TsKvDictionary;
+import org.thingsboard.server.dao.model.sqlts.dictionary.TsKvDictionaryCompositeKey;
+import org.thingsboard.server.dao.sql.JpaAbstractDaoListeningExecutorService;
+import org.thingsboard.server.dao.sqlts.dictionary.TsKvDictionaryRepository;
+
+import javax.annotation.Nullable;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.stream.Collectors;
+
+@Slf4j
+public abstract class BaseAbstractSqlTimeseriesDao extends JpaAbstractDaoListeningExecutorService {
+
+    private final ConcurrentMap<String, Integer> tsKvDictionaryMap = new ConcurrentHashMap<>();
+
+    protected static final ReentrantLock tsCreationLock = new ReentrantLock();
+
+    @Autowired
+    protected TsKvDictionaryRepository dictionaryRepository;
+
+    protected Integer getOrSaveKeyId(String strKey) {
+        Integer keyId = tsKvDictionaryMap.get(strKey);
+        if (keyId == null) {
+            Optional<TsKvDictionary> tsKvDictionaryOptional;
+            tsKvDictionaryOptional = dictionaryRepository.findById(new TsKvDictionaryCompositeKey(strKey));
+            if (!tsKvDictionaryOptional.isPresent()) {
+                tsCreationLock.lock();
+                try {
+                    tsKvDictionaryOptional = dictionaryRepository.findById(new TsKvDictionaryCompositeKey(strKey));
+                    if (!tsKvDictionaryOptional.isPresent()) {
+                        TsKvDictionary tsKvDictionary = new TsKvDictionary();
+                        tsKvDictionary.setKey(strKey);
+                        try {
+                            TsKvDictionary saved = dictionaryRepository.save(tsKvDictionary);
+                            tsKvDictionaryMap.put(saved.getKey(), saved.getKeyId());
+                            keyId = saved.getKeyId();
+                        } catch (ConstraintViolationException e) {
+                            tsKvDictionaryOptional = dictionaryRepository.findById(new TsKvDictionaryCompositeKey(strKey));
+                            TsKvDictionary dictionary = tsKvDictionaryOptional.orElseThrow(() -> new RuntimeException("Failed to get TsKvDictionary entity from DB!"));
+                            tsKvDictionaryMap.put(dictionary.getKey(), dictionary.getKeyId());
+                            keyId = dictionary.getKeyId();
+                        }
+                    } else {
+                        keyId = tsKvDictionaryOptional.get().getKeyId();
+                    }
+                } finally {
+                    tsCreationLock.unlock();
+                }
+            } else {
+                keyId = tsKvDictionaryOptional.get().getKeyId();
+                tsKvDictionaryMap.put(strKey, keyId);
+            }
+        }
+        return keyId;
+    }
+
+    protected ListenableFuture<List<TsKvEntry>> getTskvEntriesFuture(ListenableFuture<List<Optional<TsKvEntry>>> future) {
+        return Futures.transform(future, new Function<List<Optional<TsKvEntry>>, List<TsKvEntry>>() {
+            @Nullable
+            @Override
+            public List<TsKvEntry> apply(@Nullable List<Optional<TsKvEntry>> results) {
+                if (results == null || results.isEmpty()) {
+                    return null;
+                }
+                return results.stream()
+                        .filter(Optional::isPresent)
+                        .map(Optional::get)
+                        .collect(Collectors.toList());
+            }
+        }, service);
+    }
+}

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.dao.sqlts;
+
+import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.kv.Aggregation;
+import org.thingsboard.server.common.data.kv.BaseReadTsKvQuery;
+import org.thingsboard.server.common.data.kv.BasicTsKvEntry;
+import org.thingsboard.server.common.data.kv.DeleteTsKvQuery;
+import org.thingsboard.server.common.data.kv.ReadTsKvQuery;
+import org.thingsboard.server.common.data.kv.StringDataEntry;
+import org.thingsboard.server.common.data.kv.TsKvEntry;
+import org.thingsboard.server.common.stats.StatsFactory;
+import org.thingsboard.server.dao.DaoUtil;
+import org.thingsboard.server.dao.model.sqlts.latest.TsKvLatestCompositeKey;
+import org.thingsboard.server.dao.model.sqlts.latest.TsKvLatestEntity;
+import org.thingsboard.server.dao.sql.ScheduledLogExecutorComponent;
+import org.thingsboard.server.dao.sql.TbSqlBlockingQueueParams;
+import org.thingsboard.server.dao.sql.TbSqlBlockingQueueWrapper;
+import org.thingsboard.server.dao.sqlts.insert.latest.InsertLatestTsRepository;
+import org.thingsboard.server.dao.sqlts.latest.SearchTsKvLatestRepository;
+import org.thingsboard.server.dao.sqlts.latest.TsKvLatestRepository;
+import org.thingsboard.server.dao.timeseries.SimpleListenableFuture;
+import org.thingsboard.server.dao.timeseries.TimeseriesLatestDao;
+import org.thingsboard.server.dao.util.SqlTsLatestAnyDao;
+
+import javax.annotation.Nullable;
+import javax.annotation.PostConstruct;
+import javax.annotation.PreDestroy;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+
+@Slf4j
+@Component
+@SqlTsLatestAnyDao
+public class SqlTimeseriesLatestDao extends BaseAbstractSqlTimeseriesDao implements TimeseriesLatestDao {
+
+    private static final String DESC_ORDER = "DESC";
+
+    @Autowired
+    private TsKvLatestRepository tsKvLatestRepository;
+
+    @Autowired
+    protected AggregationTimeseriesDao aggregationTimeseriesDao;
+
+    @Autowired
+    private SearchTsKvLatestRepository searchTsKvLatestRepository;
+
+    @Autowired
+    private InsertLatestTsRepository insertLatestTsRepository;
+
+    private TbSqlBlockingQueueWrapper<TsKvLatestEntity> tsLatestQueue;
+
+    @Value("${sql.ts_latest.batch_size:1000}")
+    private int tsLatestBatchSize;
+
+    @Value("${sql.ts_latest.batch_max_delay:100}")
+    private long tsLatestMaxDelay;
+
+    @Value("${sql.ts_latest.stats_print_interval_ms:1000}")
+    private long tsLatestStatsPrintIntervalMs;
+
+    @Value("${sql.ts_latest.batch_threads:4}")
+    private int tsLatestBatchThreads;
+
+    @Autowired
+    protected ScheduledLogExecutorComponent logExecutor;
+
+    @Autowired
+    private StatsFactory statsFactory;
+
+    @PostConstruct
+    protected void init() {
+        TbSqlBlockingQueueParams tsLatestParams = TbSqlBlockingQueueParams.builder()
+                .logName("TS Latest")
+                .batchSize(tsLatestBatchSize)
+                .maxDelay(tsLatestMaxDelay)
+                .statsPrintIntervalMs(tsLatestStatsPrintIntervalMs)
+                .statsNamePrefix("ts.latest")
+                .build();
+
+        java.util.function.Function<TsKvLatestEntity, Integer> hashcodeFunction = entity -> entity.getEntityId().hashCode();
+        tsLatestQueue = new TbSqlBlockingQueueWrapper<>(tsLatestParams, hashcodeFunction, tsLatestBatchThreads, statsFactory);
+
+        tsLatestQueue.init(logExecutor, v -> {
+            Map<TsKey, TsKvLatestEntity> trueLatest = new HashMap<>();
+            v.forEach(ts -> {
+                TsKey key = new TsKey(ts.getEntityId(), ts.getKey());
+                TsKvLatestEntity old = trueLatest.get(key);
+                if (old == null || old.getTs() < ts.getTs()) {
+                    trueLatest.put(key, ts);
+                }
+            });
+            List<TsKvLatestEntity> latestEntities = new ArrayList<>(trueLatest.values());
+            insertLatestTsRepository.saveOrUpdate(latestEntities);
+        });
+    }
+
+    @PreDestroy
+    protected void destroy() {
+        if (tsLatestQueue != null) {
+            tsLatestQueue.destroy();
+        }
+    }
+
+    @Override
+    public ListenableFuture<Void> saveLatest(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry) {
+        return getSaveLatestFuture(entityId, tsKvEntry);
+    }
+
+    @Override
+    public ListenableFuture<Void> removeLatest(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
+        return getRemoveLatestFuture(tenantId, entityId, query);
+    }
+
+    @Override
+    public ListenableFuture<TsKvEntry> findLatest(TenantId tenantId, EntityId entityId, String key) {
+        return getFindLatestFuture(entityId, key);
+    }
+
+    @Override
+    public ListenableFuture<List<TsKvEntry>> findAllLatest(TenantId tenantId, EntityId entityId) {
+        return getFindAllLatestFuture(entityId);
+    }
+
+    private ListenableFuture<Void> getNewLatestEntryFuture(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
+        ListenableFuture<List<TsKvEntry>> future = findNewLatestEntryFuture(tenantId, entityId, query);
+        return Futures.transformAsync(future, entryList -> {
+            if (entryList.size() == 1) {
+                return getSaveLatestFuture(entityId, entryList.get(0));
+            } else {
+                log.trace("Could not find new latest value for [{}], key - {}", entityId, query.getKey());
+            }
+            return Futures.immediateFuture(null);
+        }, service);
+    }
+
+    private ListenableFuture<List<TsKvEntry>> findNewLatestEntryFuture(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
+        long startTs = 0;
+        long endTs = query.getStartTs() - 1;
+        ReadTsKvQuery findNewLatestQuery = new BaseReadTsKvQuery(query.getKey(), startTs, endTs, endTs - startTs, 1,
+                Aggregation.NONE, DESC_ORDER);
+        return aggregationTimeseriesDao.findAllAsync(tenantId, entityId, findNewLatestQuery);
+    }
+
+    protected ListenableFuture<TsKvEntry> getFindLatestFuture(EntityId entityId, String key) {
+        TsKvLatestCompositeKey compositeKey =
+                new TsKvLatestCompositeKey(
+                        entityId.getId(),
+                        getOrSaveKeyId(key));
+        Optional<TsKvLatestEntity> entry = tsKvLatestRepository.findById(compositeKey);
+        TsKvEntry result;
+        if (entry.isPresent()) {
+            TsKvLatestEntity tsKvLatestEntity = entry.get();
+            tsKvLatestEntity.setStrKey(key);
+            result = DaoUtil.getData(tsKvLatestEntity);
+        } else {
+            result = new BasicTsKvEntry(System.currentTimeMillis(), new StringDataEntry(key, null));
+        }
+        return Futures.immediateFuture(result);
+    }
+
+    protected ListenableFuture<Void> getRemoveLatestFuture(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
+        ListenableFuture<TsKvEntry> latestFuture = getFindLatestFuture(entityId, query.getKey());
+
+        ListenableFuture<Boolean> booleanFuture = Futures.transform(latestFuture, tsKvEntry -> {
+            long ts = tsKvEntry.getTs();
+            return ts > query.getStartTs() && ts <= query.getEndTs();
+        }, service);
+
+        ListenableFuture<Void> removedLatestFuture = Futures.transformAsync(booleanFuture, isRemove -> {
+            if (isRemove) {
+                TsKvLatestEntity latestEntity = new TsKvLatestEntity();
+                latestEntity.setEntityId(entityId.getId());
+                latestEntity.setKey(getOrSaveKeyId(query.getKey()));
+                return service.submit(() -> {
+                    tsKvLatestRepository.delete(latestEntity);
+                    return null;
+                });
+            }
+            return Futures.immediateFuture(null);
+        }, service);
+
+        final SimpleListenableFuture<Void> resultFuture = new SimpleListenableFuture<>();
+        Futures.addCallback(removedLatestFuture, new FutureCallback<Void>() {
+            @Override
+            public void onSuccess(@Nullable Void result) {
+                if (query.getRewriteLatestIfDeleted()) {
+                    ListenableFuture<Void> savedLatestFuture = Futures.transformAsync(booleanFuture, isRemove -> {
+                        if (isRemove) {
+                            return getNewLatestEntryFuture(tenantId, entityId, query);
+                        }
+                        return Futures.immediateFuture(null);
+                    }, service);
+
+                    try {
+                        resultFuture.set(savedLatestFuture.get());
+                    } catch (InterruptedException | ExecutionException e) {
+                        log.warn("Could not get latest saved value for [{}], {}", entityId, query.getKey(), e);
+                    }
+                } else {
+                    resultFuture.set(null);
+                }
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                log.warn("[{}] Failed to process remove of the latest value", entityId, t);
+            }
+        }, MoreExecutors.directExecutor());
+        return resultFuture;
+    }
+
+    protected ListenableFuture<List<TsKvEntry>> getFindAllLatestFuture(EntityId entityId) {
+        return Futures.immediateFuture(
+                DaoUtil.convertDataList(Lists.newArrayList(
+                        searchTsKvLatestRepository.findAllByEntityId(entityId.getId()))));
+    }
+
+    protected ListenableFuture<Void> getSaveLatestFuture(EntityId entityId, TsKvEntry tsKvEntry) {
+        TsKvLatestEntity latestEntity = new TsKvLatestEntity();
+        latestEntity.setEntityId(entityId.getId());
+        latestEntity.setTs(tsKvEntry.getTs());
+        latestEntity.setKey(getOrSaveKeyId(tsKvEntry.getKey()));
+        latestEntity.setStrValue(tsKvEntry.getStrValue().orElse(null));
+        latestEntity.setDoubleValue(tsKvEntry.getDoubleValue().orElse(null));
+        latestEntity.setLongValue(tsKvEntry.getLongValue().orElse(null));
+        latestEntity.setBooleanValue(tsKvEntry.getBooleanValue().orElse(null));
+        latestEntity.setJsonValue(tsKvEntry.getJsonValue().orElse(null));
+
+        return tsLatestQueue.add(latestEntity);
+    }
+
+}

@@ -18,11 +18,11 @@ package org.thingsboard.server.dao.sqlts.dictionary;
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.data.repository.CrudRepository;
 import org.thingsboard.server.dao.model.sqlts.dictionary.TsKvDictionary;
 import org.thingsboard.server.dao.model.sqlts.dictionary.TsKvDictionary;
 import org.thingsboard.server.dao.model.sqlts.dictionary.TsKvDictionaryCompositeKey;
 import org.thingsboard.server.dao.model.sqlts.dictionary.TsKvDictionaryCompositeKey;
-import org.thingsboard.server.dao.util.SqlTsAnyDao;
+import org.thingsboard.server.dao.util.SqlTsOrTsLatestAnyDao;
 
 
 import java.util.Optional;
 import java.util.Optional;
 
 
-@SqlTsAnyDao
+@SqlTsOrTsLatestAnyDao
 public interface TsKvDictionaryRepository extends CrudRepository<TsKvDictionary, TsKvDictionaryCompositeKey> {
 public interface TsKvDictionaryRepository extends CrudRepository<TsKvDictionary, TsKvDictionaryCompositeKey> {
 
 
     Optional<TsKvDictionary> findByKeyId(int keyId);
     Optional<TsKvDictionary> findByKeyId(int keyId);

@@ -22,14 +22,14 @@ import org.thingsboard.server.dao.model.sqlts.latest.TsKvLatestEntity;
 import org.thingsboard.server.dao.sqlts.insert.AbstractInsertRepository;
 import org.thingsboard.server.dao.sqlts.insert.AbstractInsertRepository;
 import org.thingsboard.server.dao.sqlts.insert.latest.InsertLatestTsRepository;
 import org.thingsboard.server.dao.sqlts.insert.latest.InsertLatestTsRepository;
 import org.thingsboard.server.dao.util.HsqlDao;
 import org.thingsboard.server.dao.util.HsqlDao;
-import org.thingsboard.server.dao.util.SqlTsDao;
+import org.thingsboard.server.dao.util.SqlTsLatestDao;
 
 
 import java.sql.PreparedStatement;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.sql.SQLException;
 import java.sql.Types;
 import java.sql.Types;
 import java.util.List;
 import java.util.List;
 
 
-@SqlTsDao
+@SqlTsLatestDao
 @HsqlDao
 @HsqlDao
 @Repository
 @Repository
 @Transactional
 @Transactional

@@ -23,7 +23,7 @@ import org.springframework.transaction.support.TransactionCallbackWithoutResult;
 import org.thingsboard.server.dao.model.sqlts.latest.TsKvLatestEntity;
 import org.thingsboard.server.dao.model.sqlts.latest.TsKvLatestEntity;
 import org.thingsboard.server.dao.sqlts.insert.AbstractInsertRepository;
 import org.thingsboard.server.dao.sqlts.insert.AbstractInsertRepository;
 import org.thingsboard.server.dao.sqlts.insert.latest.InsertLatestTsRepository;
 import org.thingsboard.server.dao.sqlts.insert.latest.InsertLatestTsRepository;
-import org.thingsboard.server.dao.util.PsqlTsAnyDao;
+import org.thingsboard.server.dao.util.PsqlTsLatestAnyDao;
 
 
 import java.sql.PreparedStatement;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.sql.SQLException;
@@ -32,7 +32,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.List;
 
 
 
 
-@PsqlTsAnyDao
+@PsqlTsLatestAnyDao
 @Repository
 @Repository
 @Transactional
 @Transactional
 public class PsqlLatestInsertTsRepository extends AbstractInsertRepository implements InsertLatestTsRepository {
 public class PsqlLatestInsertTsRepository extends AbstractInsertRepository implements InsertLatestTsRepository {

@@ -17,14 +17,14 @@ package org.thingsboard.server.dao.sqlts.latest;
 
 
 import org.springframework.stereotype.Repository;
 import org.springframework.stereotype.Repository;
 import org.thingsboard.server.dao.model.sqlts.latest.TsKvLatestEntity;
 import org.thingsboard.server.dao.model.sqlts.latest.TsKvLatestEntity;
-import org.thingsboard.server.dao.util.SqlTsAnyDao;
+import org.thingsboard.server.dao.util.SqlTsLatestAnyDao;
 
 
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManager;
 import javax.persistence.PersistenceContext;
 import javax.persistence.PersistenceContext;
 import java.util.List;
 import java.util.List;
 import java.util.UUID;
 import java.util.UUID;
 
 
-@SqlTsAnyDao
+@SqlTsLatestAnyDao
 @Repository
 @Repository
 public class SearchTsKvLatestRepository {
 public class SearchTsKvLatestRepository {
 
 

@@ -18,9 +18,7 @@ package org.thingsboard.server.dao.sqlts.latest;
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.data.repository.CrudRepository;
 import org.thingsboard.server.dao.model.sqlts.latest.TsKvLatestCompositeKey;
 import org.thingsboard.server.dao.model.sqlts.latest.TsKvLatestCompositeKey;
 import org.thingsboard.server.dao.model.sqlts.latest.TsKvLatestEntity;
 import org.thingsboard.server.dao.model.sqlts.latest.TsKvLatestEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
-@SqlDao
 public interface TsKvLatestRepository extends CrudRepository<TsKvLatestEntity, TsKvLatestCompositeKey> {
 public interface TsKvLatestRepository extends CrudRepository<TsKvLatestEntity, TsKvLatestCompositeKey> {
 
 
 }
 }

@@ -41,11 +41,10 @@ import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.concurrent.locks.ReentrantLock;
 
 
-
 @Component
 @Component
 @Slf4j
 @Slf4j
-@SqlTsDao
 @PsqlDao
 @PsqlDao
+@SqlTsDao
 public class JpaPsqlTimeseriesDao extends AbstractChunkedAggregationTimeseriesDao {
 public class JpaPsqlTimeseriesDao extends AbstractChunkedAggregationTimeseriesDao {
 
 
     private final Map<Long, PsqlPartition> partitions = new ConcurrentHashMap<>();
     private final Map<Long, PsqlPartition> partitions = new ConcurrentHashMap<>();

@@ -18,7 +18,7 @@ package org.thingsboard.server.dao.sqlts.timescale;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Repository;
 import org.springframework.stereotype.Repository;
 import org.thingsboard.server.dao.model.sqlts.timescale.ts.TimescaleTsKvEntity;
 import org.thingsboard.server.dao.model.sqlts.timescale.ts.TimescaleTsKvEntity;
-import org.thingsboard.server.dao.util.TimescaleDBTsDao;
+import org.thingsboard.server.dao.util.TimescaleDBTsOrTsLatestDao;
 
 
 import javax.persistence.EntityManager;
 import javax.persistence.EntityManager;
 import javax.persistence.PersistenceContext;
 import javax.persistence.PersistenceContext;
@@ -27,7 +27,7 @@ import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletableFuture;
 
 
 @Repository
 @Repository
-@TimescaleDBTsDao
+@TimescaleDBTsOrTsLatestDao
 public class AggregationRepository {
 public class AggregationRepository {
 
 
     public static final String FIND_AVG = "findAvg";
     public static final String FIND_AVG = "findAvg";

@@ -72,7 +72,6 @@ public class TimescaleTimeseriesDao extends AbstractSqlTimeseriesDao implements
 
 
     @PostConstruct
     @PostConstruct
     protected void init() {
     protected void init() {
-        super.init();
         TbSqlBlockingQueueParams tsParams = TbSqlBlockingQueueParams.builder()
         TbSqlBlockingQueueParams tsParams = TbSqlBlockingQueueParams.builder()
                 .logName("TS Timescale")
                 .logName("TS Timescale")
                 .batchSize(tsBatchSize)
                 .batchSize(tsBatchSize)
@@ -89,14 +88,60 @@ public class TimescaleTimeseriesDao extends AbstractSqlTimeseriesDao implements
 
 
     @PreDestroy
     @PreDestroy
     protected void destroy() {
     protected void destroy() {
-        super.destroy();
         if (tsQueue != null) {
         if (tsQueue != null) {
             tsQueue.destroy();
             tsQueue.destroy();
         }
         }
     }
     }
 
 
     @Override
     @Override
-    protected ListenableFuture<List<TsKvEntry>> findAllAsync(EntityId entityId, ReadTsKvQuery query) {
+    public ListenableFuture<List<TsKvEntry>> findAllAsync(TenantId tenantId, EntityId entityId, List<ReadTsKvQuery> queries) {
+        return processFindAllAsync(tenantId, entityId, queries);
+    }
+
+    @Override
+    public ListenableFuture<Void> save(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry, long ttl) {
+        String strKey = tsKvEntry.getKey();
+        Integer keyId = getOrSaveKeyId(strKey);
+        TimescaleTsKvEntity entity = new TimescaleTsKvEntity();
+        entity.setEntityId(entityId.getId());
+        entity.setTs(tsKvEntry.getTs());
+        entity.setKey(keyId);
+        entity.setStrValue(tsKvEntry.getStrValue().orElse(null));
+        entity.setDoubleValue(tsKvEntry.getDoubleValue().orElse(null));
+        entity.setLongValue(tsKvEntry.getLongValue().orElse(null));
+        entity.setBooleanValue(tsKvEntry.getBooleanValue().orElse(null));
+        entity.setJsonValue(tsKvEntry.getJsonValue().orElse(null));
+
+        log.trace("Saving entity to timescale db: {}", entity);
+        return tsQueue.add(entity);
+    }
+
+    @Override
+    public ListenableFuture<Void> savePartition(TenantId tenantId, EntityId entityId, long tsKvEntryTs, String key, long ttl) {
+        return Futures.immediateFuture(null);
+    }
+
+    @Override
+    public ListenableFuture<Void> remove(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
+        String strKey = query.getKey();
+        Integer keyId = getOrSaveKeyId(strKey);
+        return service.submit(() -> {
+            tsKvRepository.delete(
+                    entityId.getId(),
+                    keyId,
+                    query.getStartTs(),
+                    query.getEndTs());
+            return null;
+        });
+    }
+
+    @Override
+    public ListenableFuture<Void> removePartition(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
+        return service.submit(() -> null);
+    }
+
+    @Override
+    public ListenableFuture<List<TsKvEntry>> findAllAsync(TenantId tenantId, EntityId entityId, ReadTsKvQuery query) {
         if (query.getAggregation() == Aggregation.NONE) {
         if (query.getAggregation() == Aggregation.NONE) {
             return findAllAsyncWithLimit(entityId, query);
             return findAllAsyncWithLimit(entityId, query);
         } else {
         } else {
@@ -108,8 +153,7 @@ public class TimescaleTimeseriesDao extends AbstractSqlTimeseriesDao implements
         }
         }
     }
     }
 
 
-    @Override
-    protected ListenableFuture<List<TsKvEntry>> findAllAsyncWithLimit(EntityId entityId, ReadTsKvQuery query) {
+    private ListenableFuture<List<TsKvEntry>> findAllAsyncWithLimit(EntityId entityId, ReadTsKvQuery query) {
         String strKey = query.getKey();
         String strKey = query.getKey();
         Integer keyId = getOrSaveKeyId(strKey);
         Integer keyId = getOrSaveKeyId(strKey);
         List<TimescaleTsKvEntity> timescaleTsKvEntities = tsKvRepository.findAllWithLimit(
         List<TimescaleTsKvEntity> timescaleTsKvEntities = tsKvRepository.findAllWithLimit(
@@ -153,73 +197,6 @@ public class TimescaleTimeseriesDao extends AbstractSqlTimeseriesDao implements
         }, MoreExecutors.directExecutor());
         }, MoreExecutors.directExecutor());
     }
     }
 
 
-    @Override
-    public ListenableFuture<List<TsKvEntry>> findAllAsync(TenantId tenantId, EntityId entityId, List<ReadTsKvQuery> queries) {
-        return processFindAllAsync(tenantId, entityId, queries);
-    }
-
-    @Override
-    public ListenableFuture<TsKvEntry> findLatest(TenantId tenantId, EntityId entityId, String key) {
-        return getFindLatestFuture(entityId, key);
-    }
-
-    @Override
-    public ListenableFuture<List<TsKvEntry>> findAllLatest(TenantId tenantId, EntityId entityId) {
-        return getFindAllLatestFuture(entityId);
-    }
-
-    @Override
-    public ListenableFuture<Void> save(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry, long ttl) {
-        String strKey = tsKvEntry.getKey();
-        Integer keyId = getOrSaveKeyId(strKey);
-        TimescaleTsKvEntity entity = new TimescaleTsKvEntity();
-        entity.setEntityId(entityId.getId());
-        entity.setTs(tsKvEntry.getTs());
-        entity.setKey(keyId);
-        entity.setStrValue(tsKvEntry.getStrValue().orElse(null));
-        entity.setDoubleValue(tsKvEntry.getDoubleValue().orElse(null));
-        entity.setLongValue(tsKvEntry.getLongValue().orElse(null));
-        entity.setBooleanValue(tsKvEntry.getBooleanValue().orElse(null));
-        entity.setJsonValue(tsKvEntry.getJsonValue().orElse(null));
-
-        log.trace("Saving entity to timescale db: {}", entity);
-        return tsQueue.add(entity);
-    }
-
-    @Override
-    public ListenableFuture<Void> savePartition(TenantId tenantId, EntityId entityId, long tsKvEntryTs, String key, long ttl) {
-        return Futures.immediateFuture(null);
-    }
-
-    @Override
-    public ListenableFuture<Void> saveLatest(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry) {
-        return getSaveLatestFuture(entityId, tsKvEntry);
-    }
-
-    @Override
-    public ListenableFuture<Void> remove(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
-        String strKey = query.getKey();
-        Integer keyId = getOrSaveKeyId(strKey);
-        return service.submit(() -> {
-            tsKvRepository.delete(
-                    entityId.getId(),
-                    keyId,
-                    query.getStartTs(),
-                    query.getEndTs());
-            return null;
-        });
-    }
-
-    @Override
-    public ListenableFuture<Void> removeLatest(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
-        return getRemoveLatestFuture(entityId, query);
-    }
-
-    @Override
-    public ListenableFuture<Void> removePartition(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
-        return service.submit(() -> null);
-    }
-
     private CompletableFuture<List<TimescaleTsKvEntity>> switchAggregation(String key, long startTs, long endTs, long timeBucket, Aggregation aggregation, UUID entityId) {
     private CompletableFuture<List<TimescaleTsKvEntity>> switchAggregation(String key, long startTs, long endTs, long timeBucket, Aggregation aggregation, UUID entityId) {
         switch (aggregation) {
         switch (aggregation) {
             case AVG:
             case AVG:

@@ -23,12 +23,12 @@ import org.springframework.data.repository.query.Param;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.annotation.Transactional;
 import org.thingsboard.server.dao.model.sqlts.timescale.ts.TimescaleTsKvCompositeKey;
 import org.thingsboard.server.dao.model.sqlts.timescale.ts.TimescaleTsKvCompositeKey;
 import org.thingsboard.server.dao.model.sqlts.timescale.ts.TimescaleTsKvEntity;
 import org.thingsboard.server.dao.model.sqlts.timescale.ts.TimescaleTsKvEntity;
-import org.thingsboard.server.dao.util.TimescaleDBTsDao;
+import org.thingsboard.server.dao.util.TimescaleDBTsOrTsLatestDao;
 
 
 import java.util.List;
 import java.util.List;
 import java.util.UUID;
 import java.util.UUID;
 
 
-@TimescaleDBTsDao
+@TimescaleDBTsOrTsLatestDao
 public interface TsKvTimescaleRepository extends CrudRepository<TimescaleTsKvEntity, TimescaleTsKvCompositeKey> {
 public interface TsKvTimescaleRepository extends CrudRepository<TimescaleTsKvEntity, TimescaleTsKvCompositeKey> {
 
 
     @Query("SELECT tskv FROM TimescaleTsKvEntity tskv WHERE tskv.entityId = :entityId " +
     @Query("SELECT tskv FROM TimescaleTsKvEntity tskv WHERE tskv.entityId = :entityId " +

@@ -24,13 +24,11 @@ import org.springframework.scheduling.annotation.Async;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.annotation.Transactional;
 import org.thingsboard.server.dao.model.sqlts.ts.TsKvCompositeKey;
 import org.thingsboard.server.dao.model.sqlts.ts.TsKvCompositeKey;
 import org.thingsboard.server.dao.model.sqlts.ts.TsKvEntity;
 import org.thingsboard.server.dao.model.sqlts.ts.TsKvEntity;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import java.util.List;
 import java.util.List;
 import java.util.UUID;
 import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletableFuture;
 
 
-@SqlDao
 public interface TsKvRepository extends CrudRepository<TsKvEntity, TsKvCompositeKey> {
 public interface TsKvRepository extends CrudRepository<TsKvEntity, TsKvCompositeKey> {
 
 
     @Query("SELECT tskv FROM TsKvEntity tskv WHERE tskv.entityId = :entityId " +
     @Query("SELECT tskv FROM TsKvEntity tskv WHERE tskv.entityId = :entityId " +

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.dao.timeseries;
+
+import com.datastax.oss.driver.api.core.cql.Row;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.thingsboard.server.common.data.kv.BasicTsKvEntry;
+import org.thingsboard.server.common.data.kv.BooleanDataEntry;
+import org.thingsboard.server.common.data.kv.DoubleDataEntry;
+import org.thingsboard.server.common.data.kv.JsonDataEntry;
+import org.thingsboard.server.common.data.kv.KvEntry;
+import org.thingsboard.server.common.data.kv.LongDataEntry;
+import org.thingsboard.server.common.data.kv.StringDataEntry;
+import org.thingsboard.server.common.data.kv.TsKvEntry;
+import org.thingsboard.server.dao.model.ModelConstants;
+import org.thingsboard.server.dao.nosql.CassandraAbstractAsyncDao;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Slf4j
+public abstract class AbstractCassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao {
+    public static final String DESC_ORDER = "DESC";
+    public static final String GENERATED_QUERY_FOR_ENTITY_TYPE_AND_ENTITY_ID = "Generated query [{}] for entityType {} and entityId {}";
+    public static final String INSERT_INTO = "INSERT INTO ";
+    public static final String SELECT_PREFIX = "SELECT ";
+    public static final String EQUALS_PARAM = " = ? ";
+
+    public static KvEntry toKvEntry(Row row, String key) {
+        KvEntry kvEntry = null;
+        String strV = row.get(ModelConstants.STRING_VALUE_COLUMN, String.class);
+        if (strV != null) {
+            kvEntry = new StringDataEntry(key, strV);
+        } else {
+            Long longV = row.get(ModelConstants.LONG_VALUE_COLUMN, Long.class);
+            if (longV != null) {
+                kvEntry = new LongDataEntry(key, longV);
+            } else {
+                Double doubleV = row.get(ModelConstants.DOUBLE_VALUE_COLUMN, Double.class);
+                if (doubleV != null) {
+                    kvEntry = new DoubleDataEntry(key, doubleV);
+                } else {
+                    Boolean boolV = row.get(ModelConstants.BOOLEAN_VALUE_COLUMN, Boolean.class);
+                    if (boolV != null) {
+                        kvEntry = new BooleanDataEntry(key, boolV);
+                    } else {
+                        String jsonV = row.get(ModelConstants.JSON_VALUE_COLUMN, String.class);
+                        if (StringUtils.isNoneEmpty(jsonV)) {
+                            kvEntry = new JsonDataEntry(key, jsonV);
+                        } else {
+                            log.warn("All values in key-value row are nullable ");
+                        }
+                    }
+                }
+            }
+        }
+        return kvEntry;
+    }
+
+    protected List<TsKvEntry> convertResultToTsKvEntryList(List<Row> rows) {
+        List<TsKvEntry> entries = new ArrayList<>(rows.size());
+        if (!rows.isEmpty()) {
+            rows.forEach(row -> entries.add(convertResultToTsKvEntry(row)));
+        }
+        return entries;
+    }
+
+    private TsKvEntry convertResultToTsKvEntry(Row row) {
+        String key = row.getString(ModelConstants.KEY_COLUMN);
+        long ts = row.getLong(ModelConstants.TS_COLUMN);
+        return new BasicTsKvEntry(ts, toKvEntry(row, key));
+    }
+
+}

@@ -60,6 +60,9 @@ public class BaseTimeseriesService implements TimeseriesService {
     private TimeseriesDao timeseriesDao;
     private TimeseriesDao timeseriesDao;
 
 
     @Autowired
     @Autowired
+    private TimeseriesLatestDao timeseriesLatestDao;
+
+    @Autowired
     private EntityViewService entityViewService;
     private EntityViewService entityViewService;
 
 
     @Override
     @Override
@@ -103,7 +106,7 @@ public class BaseTimeseriesService implements TimeseriesService {
                 return Futures.immediateFuture(new ArrayList<>());
                 return Futures.immediateFuture(new ArrayList<>());
             }
             }
         }
         }
-        keys.forEach(key -> futures.add(timeseriesDao.findLatest(tenantId, entityId, key)));
+        keys.forEach(key -> futures.add(timeseriesLatestDao.findLatest(tenantId, entityId, key)));
         return Futures.allAsList(futures);
         return Futures.allAsList(futures);
     }
     }
 
 
@@ -119,7 +122,7 @@ public class BaseTimeseriesService implements TimeseriesService {
                 return Futures.immediateFuture(new ArrayList<>());
                 return Futures.immediateFuture(new ArrayList<>());
             }
             }
         } else {
         } else {
-            return timeseriesDao.findAllLatest(tenantId, entityId);
+            return timeseriesLatestDao.findAllLatest(tenantId, entityId);
         }
         }
     }
     }
 
 
@@ -151,7 +154,7 @@ public class BaseTimeseriesService implements TimeseriesService {
             throw new IncorrectParameterException("Telemetry data can't be stored for entity view. Read only");
             throw new IncorrectParameterException("Telemetry data can't be stored for entity view. Read only");
         }
         }
         futures.add(timeseriesDao.savePartition(tenantId, entityId, tsKvEntry.getTs(), tsKvEntry.getKey(), ttl));
         futures.add(timeseriesDao.savePartition(tenantId, entityId, tsKvEntry.getTs(), tsKvEntry.getKey(), ttl));
-        futures.add(timeseriesDao.saveLatest(tenantId, entityId, tsKvEntry));
+        futures.add(timeseriesLatestDao.saveLatest(tenantId, entityId, tsKvEntry));
         futures.add(timeseriesDao.save(tenantId, entityId, tsKvEntry, ttl));
         futures.add(timeseriesDao.save(tenantId, entityId, tsKvEntry, ttl));
     }
     }
 
 
@@ -187,7 +190,7 @@ public class BaseTimeseriesService implements TimeseriesService {
 
 
     private void deleteAndRegisterFutures(TenantId tenantId, List<ListenableFuture<Void>> futures, EntityId entityId, DeleteTsKvQuery query) {
     private void deleteAndRegisterFutures(TenantId tenantId, List<ListenableFuture<Void>> futures, EntityId entityId, DeleteTsKvQuery query) {
         futures.add(timeseriesDao.remove(tenantId, entityId, query));
         futures.add(timeseriesDao.remove(tenantId, entityId, query));
-        futures.add(timeseriesDao.removeLatest(tenantId, entityId, query));
+        futures.add(timeseriesLatestDao.removeLatest(tenantId, entityId, query));
         futures.add(timeseriesDao.removePartition(tenantId, entityId, query));
         futures.add(timeseriesDao.removePartition(tenantId, entityId, query));
     }
     }
 
 

@@ -20,7 +20,6 @@ import com.datastax.oss.driver.api.core.cql.BoundStatement;
 import com.datastax.oss.driver.api.core.cql.BoundStatementBuilder;
 import com.datastax.oss.driver.api.core.cql.BoundStatementBuilder;
 import com.datastax.oss.driver.api.core.cql.PreparedStatement;
 import com.datastax.oss.driver.api.core.cql.PreparedStatement;
 import com.datastax.oss.driver.api.core.cql.Row;
 import com.datastax.oss.driver.api.core.cql.Row;
-import com.datastax.oss.driver.api.core.cql.Statement;
 import com.datastax.oss.driver.api.querybuilder.QueryBuilder;
 import com.datastax.oss.driver.api.querybuilder.QueryBuilder;
 import com.datastax.oss.driver.api.querybuilder.select.Select;
 import com.datastax.oss.driver.api.querybuilder.select.Select;
 import com.google.common.base.Function;
 import com.google.common.base.Function;
@@ -30,7 +29,6 @@ import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.MoreExecutors;
 import com.google.common.util.concurrent.MoreExecutors;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
-import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.core.env.Environment;
 import org.springframework.core.env.Environment;
@@ -39,21 +37,15 @@ import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.kv.Aggregation;
 import org.thingsboard.server.common.data.kv.Aggregation;
 import org.thingsboard.server.common.data.kv.BaseReadTsKvQuery;
 import org.thingsboard.server.common.data.kv.BaseReadTsKvQuery;
-import org.thingsboard.server.common.data.kv.BasicTsKvEntry;
-import org.thingsboard.server.common.data.kv.BooleanDataEntry;
 import org.thingsboard.server.common.data.kv.DataType;
 import org.thingsboard.server.common.data.kv.DataType;
 import org.thingsboard.server.common.data.kv.DeleteTsKvQuery;
 import org.thingsboard.server.common.data.kv.DeleteTsKvQuery;
-import org.thingsboard.server.common.data.kv.DoubleDataEntry;
-import org.thingsboard.server.common.data.kv.JsonDataEntry;
 import org.thingsboard.server.common.data.kv.KvEntry;
 import org.thingsboard.server.common.data.kv.KvEntry;
-import org.thingsboard.server.common.data.kv.LongDataEntry;
 import org.thingsboard.server.common.data.kv.ReadTsKvQuery;
 import org.thingsboard.server.common.data.kv.ReadTsKvQuery;
-import org.thingsboard.server.common.data.kv.StringDataEntry;
 import org.thingsboard.server.common.data.kv.TsKvEntry;
 import org.thingsboard.server.common.data.kv.TsKvEntry;
 import org.thingsboard.server.dao.model.ModelConstants;
 import org.thingsboard.server.dao.model.ModelConstants;
-import org.thingsboard.server.dao.nosql.CassandraAbstractAsyncDao;
 import org.thingsboard.server.dao.nosql.TbResultSet;
 import org.thingsboard.server.dao.nosql.TbResultSet;
 import org.thingsboard.server.dao.nosql.TbResultSetFuture;
 import org.thingsboard.server.dao.nosql.TbResultSetFuture;
+import org.thingsboard.server.dao.sqlts.AggregationTimeseriesDao;
 import org.thingsboard.server.dao.util.NoSqlTsDao;
 import org.thingsboard.server.dao.util.NoSqlTsDao;
 
 
 import javax.annotation.Nullable;
 import javax.annotation.Nullable;
@@ -68,7 +60,6 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.Collections;
 import java.util.List;
 import java.util.List;
 import java.util.Optional;
 import java.util.Optional;
-import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
 import java.util.stream.Collectors;
 
 
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.literal;
 import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.literal;
@@ -79,16 +70,11 @@ import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.literal;
 @Component
 @Component
 @Slf4j
 @Slf4j
 @NoSqlTsDao
 @NoSqlTsDao
-public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implements TimeseriesDao {
+public class CassandraBaseTimeseriesDao extends AbstractCassandraBaseTimeseriesDao implements TimeseriesDao, AggregationTimeseriesDao {
 
 
-    private static final int MIN_AGGREGATION_STEP_MS = 1000;
-    public static final String INSERT_INTO = "INSERT INTO ";
-    public static final String GENERATED_QUERY_FOR_ENTITY_TYPE_AND_ENTITY_ID = "Generated query [{}] for entityType {} and entityId {}";
-    public static final String SELECT_PREFIX = "SELECT ";
-    public static final String EQUALS_PARAM = " = ? ";
+    protected static final int MIN_AGGREGATION_STEP_MS = 1000;
     public static final String ASC_ORDER = "ASC";
     public static final String ASC_ORDER = "ASC";
-    public static final String DESC_ORDER = "DESC";
-    private static List<Long> FIXED_PARTITION = Arrays.asList(new Long[]{0L});
+    protected static List<Long> FIXED_PARTITION = Arrays.asList(new Long[]{0L});
 
 
     @Autowired
     @Autowired
     private Environment environment;
     private Environment environment;
@@ -106,13 +92,10 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
 
 
     private PreparedStatement partitionInsertStmt;
     private PreparedStatement partitionInsertStmt;
     private PreparedStatement partitionInsertTtlStmt;
     private PreparedStatement partitionInsertTtlStmt;
-    private PreparedStatement latestInsertStmt;
     private PreparedStatement[] saveStmts;
     private PreparedStatement[] saveStmts;
     private PreparedStatement[] saveTtlStmts;
     private PreparedStatement[] saveTtlStmts;
     private PreparedStatement[] fetchStmtsAsc;
     private PreparedStatement[] fetchStmtsAsc;
     private PreparedStatement[] fetchStmtsDesc;
     private PreparedStatement[] fetchStmtsDesc;
-    private PreparedStatement findLatestStmt;
-    private PreparedStatement findAllLatestStmt;
     private PreparedStatement deleteStmt;
     private PreparedStatement deleteStmt;
     private PreparedStatement deletePartitionStmt;
     private PreparedStatement deletePartitionStmt;
 
 
@@ -157,8 +140,113 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         }, readResultsProcessingExecutor);
         }, readResultsProcessingExecutor);
     }
     }
 
 
+    @Override
+    public ListenableFuture<Void> save(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry, long ttl) {
+        List<ListenableFuture<Void>> futures = new ArrayList<>();
+        ttl = computeTtl(ttl);
+        long partition = toPartitionTs(tsKvEntry.getTs());
+        DataType type = tsKvEntry.getDataType();
+        if (setNullValuesEnabled) {
+            processSetNullValues(tenantId, entityId, tsKvEntry, ttl, futures, partition, type);
+        }
+        BoundStatementBuilder stmtBuilder = new BoundStatementBuilder((ttl == 0 ? getSaveStmt(type) : getSaveTtlStmt(type)).bind());
+        stmtBuilder.setString(0, entityId.getEntityType().name())
+                .setUuid(1, entityId.getId())
+                .setString(2, tsKvEntry.getKey())
+                .setLong(3, partition)
+                .setLong(4, tsKvEntry.getTs());
+        addValue(tsKvEntry, stmtBuilder, 5);
+        if (ttl > 0) {
+            stmtBuilder.setInt(6, (int) ttl);
+        }
+        BoundStatement stmt = stmtBuilder.build();
+        futures.add(getFuture(executeAsyncWrite(tenantId, stmt), rs -> null));
+        return Futures.transform(Futures.allAsList(futures), result -> null, MoreExecutors.directExecutor());
+    }
+
+    @Override
+    public ListenableFuture<Void> savePartition(TenantId tenantId, EntityId entityId, long tsKvEntryTs, String key, long ttl) {
+        if (isFixedPartitioning()) {
+            return Futures.immediateFuture(null);
+        }
+        ttl = computeTtl(ttl);
+        long partition = toPartitionTs(tsKvEntryTs);
+        log.debug("Saving partition {} for the entity [{}-{}] and key {}", partition, entityId.getEntityType(), entityId.getId(), key);
+        BoundStatementBuilder stmtBuilder = new BoundStatementBuilder((ttl == 0 ? getPartitionInsertStmt() : getPartitionInsertTtlStmt()).bind());
+        stmtBuilder.setString(0, entityId.getEntityType().name())
+                .setUuid(1, entityId.getId())
+                .setLong(2, partition)
+                .setString(3, key);
+        if (ttl > 0) {
+            stmtBuilder.setInt(4, (int) ttl);
+        }
+        BoundStatement stmt = stmtBuilder.build();
+        return getFuture(executeAsyncWrite(tenantId, stmt), rs -> null);
+    }
 
 
-    private ListenableFuture<List<TsKvEntry>> findAllAsync(TenantId tenantId, EntityId entityId, ReadTsKvQuery query) {
+    @Override
+    public ListenableFuture<Void> remove(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
+        long minPartition = toPartitionTs(query.getStartTs());
+        long maxPartition = toPartitionTs(query.getEndTs());
+
+        TbResultSetFuture partitionsFuture = fetchPartitions(tenantId, entityId, query.getKey(), minPartition, maxPartition);
+
+        final SimpleListenableFuture<Void> resultFuture = new SimpleListenableFuture<>();
+        final ListenableFuture<List<Long>> partitionsListFuture = Futures.transformAsync(partitionsFuture, getPartitionsArrayFunction(), readResultsProcessingExecutor);
+
+        Futures.addCallback(partitionsListFuture, new FutureCallback<List<Long>>() {
+            @Override
+            public void onSuccess(@Nullable List<Long> partitions) {
+                QueryCursor cursor = new QueryCursor(entityId.getEntityType().name(), entityId.getId(), query, partitions);
+                deleteAsync(tenantId, cursor, resultFuture);
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                log.error("[{}][{}] Failed to fetch partitions for interval {}-{}", entityId.getEntityType().name(), entityId.getId(), minPartition, maxPartition, t);
+            }
+        }, readResultsProcessingExecutor);
+        return resultFuture;
+    }
+
+    @Override
+    public ListenableFuture<Void> removePartition(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
+        long minPartition = toPartitionTs(query.getStartTs());
+        long maxPartition = toPartitionTs(query.getEndTs());
+        if (minPartition == maxPartition) {
+            return Futures.immediateFuture(null);
+        } else {
+            TbResultSetFuture partitionsFuture = fetchPartitions(tenantId, entityId, query.getKey(), minPartition, maxPartition);
+
+            final SimpleListenableFuture<Void> resultFuture = new SimpleListenableFuture<>();
+            final ListenableFuture<List<Long>> partitionsListFuture = Futures.transformAsync(partitionsFuture, getPartitionsArrayFunction(), readResultsProcessingExecutor);
+
+            Futures.addCallback(partitionsListFuture, new FutureCallback<List<Long>>() {
+                @Override
+                public void onSuccess(@Nullable List<Long> partitions) {
+                    int index = 0;
+                    if (minPartition != query.getStartTs()) {
+                        index = 1;
+                    }
+                    List<Long> partitionsToDelete = new ArrayList<>();
+                    for (int i = index; i < partitions.size() - 1; i++) {
+                        partitionsToDelete.add(partitions.get(i));
+                    }
+                    QueryCursor cursor = new QueryCursor(entityId.getEntityType().name(), entityId.getId(), query, partitionsToDelete);
+                    deletePartitionAsync(tenantId, cursor, resultFuture);
+                }
+
+                @Override
+                public void onFailure(Throwable t) {
+                    log.error("[{}][{}] Failed to fetch partitions for interval {}-{}", entityId.getEntityType().name(), entityId.getId(), minPartition, maxPartition, t);
+                }
+            }, readResultsProcessingExecutor);
+            return resultFuture;
+        }
+    }
+
+    @Override
+    public ListenableFuture<List<TsKvEntry>> findAllAsync(TenantId tenantId, EntityId entityId, ReadTsKvQuery query) {
         if (query.getAggregation() == Aggregation.NONE) {
         if (query.getAggregation() == Aggregation.NONE) {
             return findAllAsyncWithLimit(tenantId, entityId, query);
             return findAllAsyncWithLimit(tenantId, entityId, query);
         } else {
         } else {
@@ -183,18 +271,6 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         }
         }
     }
     }
 
 
-    public boolean isFixedPartitioning() {
-        return tsFormat.getTruncateUnit().equals(ChronoUnit.FOREVER);
-    }
-
-    private ListenableFuture<List<Long>> getPartitionsFuture(TenantId tenantId, ReadTsKvQuery query, EntityId entityId, long minPartition, long maxPartition) {
-        if (isFixedPartitioning()) { //no need to fetch partitions from DB
-            return Futures.immediateFuture(FIXED_PARTITION);
-        }
-        TbResultSetFuture partitionsFuture = fetchPartitions(tenantId, entityId, query.getKey(), minPartition, maxPartition);
-        return Futures.transformAsync(partitionsFuture, getPartitionsArrayFunction(), readResultsProcessingExecutor);
-    }
-
     private ListenableFuture<List<TsKvEntry>> findAllAsyncWithLimit(TenantId tenantId, EntityId entityId, ReadTsKvQuery query) {
     private ListenableFuture<List<TsKvEntry>> findAllAsyncWithLimit(TenantId tenantId, EntityId entityId, ReadTsKvQuery query) {
         long minPartition = toPartitionTs(query.getStartTs());
         long minPartition = toPartitionTs(query.getStartTs());
         long maxPartition = toPartitionTs(query.getEndTs());
         long maxPartition = toPartitionTs(query.getEndTs());
@@ -287,10 +363,18 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
 
 
     private AsyncFunction<TbResultSet, List<Long>> getPartitionsArrayFunction() {
     private AsyncFunction<TbResultSet, List<Long>> getPartitionsArrayFunction() {
         return rs ->
         return rs ->
-            Futures.transform(rs.allRows(readResultsProcessingExecutor), rows ->
-                rows.stream()
-                .map(row -> row.getLong(ModelConstants.PARTITION_COLUMN)).collect(Collectors.toList()),
-                    readResultsProcessingExecutor);
+                Futures.transform(rs.allRows(readResultsProcessingExecutor), rows ->
+                                rows.stream()
+                                        .map(row -> row.getLong(ModelConstants.PARTITION_COLUMN)).collect(Collectors.toList()),
+                        readResultsProcessingExecutor);
+    }
+
+    private ListenableFuture<List<Long>> getPartitionsFuture(TenantId tenantId, ReadTsKvQuery query, EntityId entityId, long minPartition, long maxPartition) {
+        if (isFixedPartitioning()) { //no need to fetch partitions from DB
+            return Futures.immediateFuture(FIXED_PARTITION);
+        }
+        TbResultSetFuture partitionsFuture = fetchPartitions(tenantId, entityId, query.getKey(), minPartition, maxPartition);
+        return Futures.transformAsync(partitionsFuture, getPartitionsArrayFunction(), readResultsProcessingExecutor);
     }
     }
 
 
     private AsyncFunction<List<Long>, List<TbResultSet>> getFetchChunksAsyncFunction(TenantId tenantId, EntityId entityId, String key, Aggregation aggregation, long startTs, long endTs) {
     private AsyncFunction<List<Long>, List<TbResultSet>> getFetchChunksAsyncFunction(TenantId tenantId, EntityId entityId, String key, Aggregation aggregation, long startTs, long endTs) {
@@ -319,49 +403,8 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         };
         };
     }
     }
 
 
-    @Override
-    public ListenableFuture<TsKvEntry> findLatest(TenantId tenantId, EntityId entityId, String key) {
-        BoundStatementBuilder stmtBuilder = new BoundStatementBuilder(getFindLatestStmt().bind());
-        stmtBuilder.setString(0, entityId.getEntityType().name());
-        stmtBuilder.setUuid(1, entityId.getId());
-        stmtBuilder.setString(2, key);
-        BoundStatement stmt = stmtBuilder.build();
-        log.debug(GENERATED_QUERY_FOR_ENTITY_TYPE_AND_ENTITY_ID, stmt, entityId.getEntityType(), entityId.getId());
-        return getFuture(executeAsyncRead(tenantId, stmt), rs -> convertResultToTsKvEntry(key, rs.one()));
-    }
-
-    @Override
-    public ListenableFuture<List<TsKvEntry>> findAllLatest(TenantId tenantId, EntityId entityId) {
-        BoundStatementBuilder stmtBuilder = new BoundStatementBuilder(getFindAllLatestStmt().bind());
-        stmtBuilder.setString(0, entityId.getEntityType().name());
-        stmtBuilder.setUuid(1, entityId.getId());
-        BoundStatement stmt = stmtBuilder.build();
-        log.debug(GENERATED_QUERY_FOR_ENTITY_TYPE_AND_ENTITY_ID, stmt, entityId.getEntityType(), entityId.getId());
-        return getFutureAsync(executeAsyncRead(tenantId, stmt), rs -> convertAsyncResultSetToTsKvEntryList(rs));
-    }
-
-    @Override
-    public ListenableFuture<Void> save(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry, long ttl) {
-        List<ListenableFuture<Void>> futures = new ArrayList<>();
-        ttl = computeTtl(ttl);
-        long partition = toPartitionTs(tsKvEntry.getTs());
-        DataType type = tsKvEntry.getDataType();
-        if (setNullValuesEnabled) {
-            processSetNullValues(tenantId, entityId, tsKvEntry, ttl, futures, partition, type);
-        }
-        BoundStatementBuilder stmtBuilder = new BoundStatementBuilder((ttl == 0 ? getSaveStmt(type) : getSaveTtlStmt(type)).bind());
-        stmtBuilder.setString(0, entityId.getEntityType().name())
-                .setUuid(1, entityId.getId())
-                .setString(2, tsKvEntry.getKey())
-                .setLong(3, partition)
-                .setLong(4, tsKvEntry.getTs());
-        addValue(tsKvEntry, stmtBuilder, 5);
-        if (ttl > 0) {
-            stmtBuilder.setInt(6, (int) ttl);
-        }
-        BoundStatement stmt = stmtBuilder.build();
-        futures.add(getFuture(executeAsyncWrite(tenantId, stmt), rs -> null));
-        return Futures.transform(Futures.allAsList(futures), result -> null, MoreExecutors.directExecutor());
+    private boolean isFixedPartitioning() {
+        return tsFormat.getTruncateUnit().equals(ChronoUnit.FOREVER);
     }
     }
 
 
     private void processSetNullValues(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry, long ttl, List<ListenableFuture<Void>> futures, long partition, DataType type) {
     private void processSetNullValues(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry, long ttl, List<ListenableFuture<Void>> futures, long partition, DataType type) {
@@ -414,26 +457,6 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         return getFuture(executeAsyncWrite(tenantId, stmt), rs -> null);
         return getFuture(executeAsyncWrite(tenantId, stmt), rs -> null);
     }
     }
 
 
-    @Override
-    public ListenableFuture<Void> savePartition(TenantId tenantId, EntityId entityId, long tsKvEntryTs, String key, long ttl) {
-        if (isFixedPartitioning()) {
-            return Futures.immediateFuture(null);
-        }
-        ttl = computeTtl(ttl);
-        long partition = toPartitionTs(tsKvEntryTs);
-        log.debug("Saving partition {} for the entity [{}-{}] and key {}", partition, entityId.getEntityType(), entityId.getId(), key);
-        BoundStatementBuilder stmtBuilder = new BoundStatementBuilder((ttl == 0 ? getPartitionInsertStmt() : getPartitionInsertTtlStmt()).bind());
-        stmtBuilder.setString(0, entityId.getEntityType().name())
-                .setUuid(1, entityId.getId())
-                .setLong(2, partition)
-                .setString(3, key);
-        if (ttl > 0) {
-            stmtBuilder.setInt(4, (int) ttl);
-        }
-        BoundStatement stmt = stmtBuilder.build();
-        return getFuture(executeAsyncWrite(tenantId, stmt), rs -> null);
-    }
-
     private long computeTtl(long ttl) {
     private long computeTtl(long ttl) {
         if (systemTtl > 0) {
         if (systemTtl > 0) {
             if (ttl == 0) {
             if (ttl == 0) {
@@ -445,53 +468,6 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         return ttl;
         return ttl;
     }
     }
 
 
-    @Override
-    public ListenableFuture<Void> saveLatest(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry) {
-        BoundStatementBuilder stmtBuilder = new BoundStatementBuilder(getLatestStmt().bind());
-        stmtBuilder.setString(0, entityId.getEntityType().name())
-                .setUuid(1, entityId.getId())
-                .setString(2, tsKvEntry.getKey())
-                .setLong(3, tsKvEntry.getTs())
-                .set(4, tsKvEntry.getBooleanValue().orElse(null), Boolean.class)
-                .set(5, tsKvEntry.getStrValue().orElse(null), String.class)
-                .set(6, tsKvEntry.getLongValue().orElse(null), Long.class)
-                .set(7, tsKvEntry.getDoubleValue().orElse(null), Double.class);
-        Optional<String> jsonV = tsKvEntry.getJsonValue();
-        if (jsonV.isPresent()) {
-            stmtBuilder.setString(8, tsKvEntry.getJsonValue().get());
-        } else {
-            stmtBuilder.setToNull(8);
-        }
-        BoundStatement stmt = stmtBuilder.build();
-
-        return getFuture(executeAsyncWrite(tenantId, stmt), rs -> null);
-    }
-
-    @Override
-    public ListenableFuture<Void> remove(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
-        long minPartition = toPartitionTs(query.getStartTs());
-        long maxPartition = toPartitionTs(query.getEndTs());
-
-        TbResultSetFuture partitionsFuture = fetchPartitions(tenantId, entityId, query.getKey(), minPartition, maxPartition);
-
-        final SimpleListenableFuture<Void> resultFuture = new SimpleListenableFuture<>();
-        final ListenableFuture<List<Long>> partitionsListFuture = Futures.transformAsync(partitionsFuture, getPartitionsArrayFunction(), readResultsProcessingExecutor);
-
-        Futures.addCallback(partitionsListFuture, new FutureCallback<List<Long>>() {
-            @Override
-            public void onSuccess(@Nullable List<Long> partitions) {
-                QueryCursor cursor = new QueryCursor(entityId.getEntityType().name(), entityId.getId(), query, partitions);
-                deleteAsync(tenantId, cursor, resultFuture);
-            }
-
-            @Override
-            public void onFailure(Throwable t) {
-                log.error("[{}][{}] Failed to fetch partitions for interval {}-{}", entityId.getEntityType().name(), entityId.getId(), minPartition, maxPartition, t);
-            }
-        }, readResultsProcessingExecutor);
-        return resultFuture;
-    }
-
     private void deleteAsync(TenantId tenantId, final QueryCursor cursor, final SimpleListenableFuture<Void> resultFuture) {
     private void deleteAsync(TenantId tenantId, final QueryCursor cursor, final SimpleListenableFuture<Void> resultFuture) {
         if (!cursor.hasNextPartition()) {
         if (!cursor.hasNextPartition()) {
             resultFuture.set(null);
             resultFuture.set(null);
@@ -534,119 +510,6 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         return deleteStmt;
         return deleteStmt;
     }
     }
 
 
-    @Override
-    public ListenableFuture<Void> removeLatest(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
-        ListenableFuture<TsKvEntry> latestEntryFuture = findLatest(tenantId, entityId, query.getKey());
-
-        ListenableFuture<Boolean> booleanFuture = Futures.transform(latestEntryFuture, latestEntry -> {
-            long ts = latestEntry.getTs();
-            if (ts > query.getStartTs() && ts <= query.getEndTs()) {
-                return true;
-            } else {
-                log.trace("Won't be deleted latest value for [{}], key - {}", entityId, query.getKey());
-            }
-            return false;
-        }, readResultsProcessingExecutor);
-
-        ListenableFuture<Void> removedLatestFuture = Futures.transformAsync(booleanFuture, isRemove -> {
-            if (isRemove) {
-                return deleteLatest(tenantId, entityId, query.getKey());
-            }
-            return Futures.immediateFuture(null);
-        }, readResultsProcessingExecutor);
-
-        final SimpleListenableFuture<Void> resultFuture = new SimpleListenableFuture<>();
-        Futures.addCallback(removedLatestFuture, new FutureCallback<Void>() {
-            @Override
-            public void onSuccess(@Nullable Void result) {
-                if (query.getRewriteLatestIfDeleted()) {
-                    ListenableFuture<Void> savedLatestFuture = Futures.transformAsync(booleanFuture, isRemove -> {
-                        if (isRemove) {
-                            return getNewLatestEntryFuture(tenantId, entityId, query);
-                        }
-                        return Futures.immediateFuture(null);
-                    }, readResultsProcessingExecutor);
-
-                    try {
-                        resultFuture.set(savedLatestFuture.get());
-                    } catch (InterruptedException | ExecutionException e) {
-                        log.warn("Could not get latest saved value for [{}], {}", entityId, query.getKey(), e);
-                    }
-                } else {
-                    resultFuture.set(null);
-                }
-            }
-
-            @Override
-            public void onFailure(Throwable t) {
-                log.warn("[{}] Failed to process remove of the latest value", entityId, t);
-            }
-        }, MoreExecutors.directExecutor());
-        return resultFuture;
-    }
-
-    private ListenableFuture<Void> getNewLatestEntryFuture(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
-        long startTs = 0;
-        long endTs = query.getStartTs() - 1;
-        ReadTsKvQuery findNewLatestQuery = new BaseReadTsKvQuery(query.getKey(), startTs, endTs, endTs - startTs, 1,
-                Aggregation.NONE, DESC_ORDER);
-        ListenableFuture<List<TsKvEntry>> future = findAllAsync(tenantId, entityId, findNewLatestQuery);
-
-        return Futures.transformAsync(future, entryList -> {
-            if (entryList.size() == 1) {
-                return saveLatest(tenantId, entityId, entryList.get(0));
-            } else {
-                log.trace("Could not find new latest value for [{}], key - {}", entityId, query.getKey());
-            }
-            return Futures.immediateFuture(null);
-        }, readResultsProcessingExecutor);
-    }
-
-    private ListenableFuture<Void> deleteLatest(TenantId tenantId, EntityId entityId, String key) {
-        Statement delete = QueryBuilder.deleteFrom(ModelConstants.TS_KV_LATEST_CF)
-                .whereColumn(ModelConstants.ENTITY_TYPE_COLUMN).isEqualTo(literal(entityId.getEntityType().name()))
-                .whereColumn(ModelConstants.ENTITY_ID_COLUMN).isEqualTo(literal(entityId.getId()))
-                .whereColumn(ModelConstants.KEY_COLUMN).isEqualTo(literal(key)).build();
-        log.debug("Remove request: {}", delete.toString());
-        return getFuture(executeAsyncWrite(tenantId, delete), rs -> null);
-    }
-
-    @Override
-    public ListenableFuture<Void> removePartition(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
-        long minPartition = toPartitionTs(query.getStartTs());
-        long maxPartition = toPartitionTs(query.getEndTs());
-        if (minPartition == maxPartition) {
-            return Futures.immediateFuture(null);
-        } else {
-            TbResultSetFuture partitionsFuture = fetchPartitions(tenantId, entityId, query.getKey(), minPartition, maxPartition);
-
-            final SimpleListenableFuture<Void> resultFuture = new SimpleListenableFuture<>();
-            final ListenableFuture<List<Long>> partitionsListFuture = Futures.transformAsync(partitionsFuture, getPartitionsArrayFunction(), readResultsProcessingExecutor);
-
-            Futures.addCallback(partitionsListFuture, new FutureCallback<List<Long>>() {
-                @Override
-                public void onSuccess(@Nullable List<Long> partitions) {
-                    int index = 0;
-                    if (minPartition != query.getStartTs()) {
-                        index = 1;
-                    }
-                    List<Long> partitionsToDelete = new ArrayList<>();
-                    for (int i = index; i < partitions.size() - 1; i++) {
-                        partitionsToDelete.add(partitions.get(i));
-                    }
-                    QueryCursor cursor = new QueryCursor(entityId.getEntityType().name(), entityId.getId(), query, partitionsToDelete);
-                    deletePartitionAsync(tenantId, cursor, resultFuture);
-                }
-
-                @Override
-                public void onFailure(Throwable t) {
-                    log.error("[{}][{}] Failed to fetch partitions for interval {}-{}", entityId.getEntityType().name(), entityId.getId(), minPartition, maxPartition, t);
-                }
-            }, readResultsProcessingExecutor);
-            return resultFuture;
-        }
-    }
-
     private void deletePartitionAsync(TenantId tenantId, final QueryCursor cursor, final SimpleListenableFuture<Void> resultFuture) {
     private void deletePartitionAsync(TenantId tenantId, final QueryCursor cursor, final SimpleListenableFuture<Void> resultFuture) {
         if (!cursor.hasNextPartition()) {
         if (!cursor.hasNextPartition()) {
             resultFuture.set(null);
             resultFuture.set(null);
@@ -685,79 +548,6 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         return deletePartitionStmt;
         return deletePartitionStmt;
     }
     }
 
 
-    private ListenableFuture<List<TsKvEntry>> convertAsyncResultSetToTsKvEntryList(TbResultSet rs) {
-        return Futures.transform(rs.allRows(readResultsProcessingExecutor),
-                rows -> this.convertResultToTsKvEntryList(rows), readResultsProcessingExecutor);
-    }
-
-    private List<TsKvEntry> convertResultToTsKvEntryList(List<Row> rows) {
-        List<TsKvEntry> entries = new ArrayList<>(rows.size());
-        if (!rows.isEmpty()) {
-            rows.forEach(row -> entries.add(convertResultToTsKvEntry(row)));
-        }
-        return entries;
-    }
-
-    private TsKvEntry convertResultToTsKvEntry(String key, Row row) {
-        if (row != null) {
-            long ts = row.getLong(ModelConstants.TS_COLUMN);
-            return new BasicTsKvEntry(ts, toKvEntry(row, key));
-        } else {
-            return new BasicTsKvEntry(System.currentTimeMillis(), new StringDataEntry(key, null));
-        }
-    }
-
-    private TsKvEntry convertResultToTsKvEntry(Row row) {
-        String key = row.getString(ModelConstants.KEY_COLUMN);
-        long ts = row.getLong(ModelConstants.TS_COLUMN);
-        return new BasicTsKvEntry(ts, toKvEntry(row, key));
-    }
-
-    public static KvEntry toKvEntry(Row row, String key) {
-        KvEntry kvEntry = null;
-        String strV = row.get(ModelConstants.STRING_VALUE_COLUMN, String.class);
-        if (strV != null) {
-            kvEntry = new StringDataEntry(key, strV);
-        } else {
-            Long longV = row.get(ModelConstants.LONG_VALUE_COLUMN, Long.class);
-            if (longV != null) {
-                kvEntry = new LongDataEntry(key, longV);
-            } else {
-                Double doubleV = row.get(ModelConstants.DOUBLE_VALUE_COLUMN, Double.class);
-                if (doubleV != null) {
-                    kvEntry = new DoubleDataEntry(key, doubleV);
-                } else {
-                    Boolean boolV = row.get(ModelConstants.BOOLEAN_VALUE_COLUMN, Boolean.class);
-                    if (boolV != null) {
-                        kvEntry = new BooleanDataEntry(key, boolV);
-                    } else {
-                        String jsonV = row.get(ModelConstants.JSON_VALUE_COLUMN, String.class);
-                        if (StringUtils.isNoneEmpty(jsonV)) {
-                            kvEntry = new JsonDataEntry(key, jsonV);
-                        } else {
-                            log.warn("All values in key-value row are nullable ");
-                        }
-                    }
-                }
-            }
-        }
-        return kvEntry;
-    }
-
-    /**
-     * Select existing partitions from the table
-     * <code>{@link ModelConstants#TS_KV_PARTITIONS_CF}</code> for the given entity
-     */
-    private TbResultSetFuture fetchPartitions(TenantId tenantId, EntityId entityId, String key, long minPartition, long maxPartition) {
-        Select select = QueryBuilder.selectFrom(ModelConstants.TS_KV_PARTITIONS_CF).column(ModelConstants.PARTITION_COLUMN)
-                .whereColumn(ModelConstants.ENTITY_TYPE_COLUMN).isEqualTo(literal(entityId.getEntityType().name()))
-                .whereColumn(ModelConstants.ENTITY_ID_COLUMN).isEqualTo(literal(entityId.getId()))
-                .whereColumn(ModelConstants.KEY_COLUMN).isEqualTo(literal(key))
-                .whereColumn(ModelConstants.PARTITION_COLUMN).isGreaterThanOrEqualTo(literal(minPartition))
-                .whereColumn(ModelConstants.PARTITION_COLUMN).isLessThanOrEqualTo(literal(maxPartition));
-        return executeAsyncRead(tenantId, select.build());
-    }
-
     private PreparedStatement getSaveStmt(DataType dataType) {
     private PreparedStatement getSaveStmt(DataType dataType) {
         if (saveStmts == null) {
         if (saveStmts == null) {
             saveStmts = new PreparedStatement[DataType.values().length];
             saveStmts = new PreparedStatement[DataType.values().length];
@@ -792,63 +582,6 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         return saveTtlStmts[dataType.ordinal()];
         return saveTtlStmts[dataType.ordinal()];
     }
     }
 
 
-    private PreparedStatement getFetchStmt(Aggregation aggType, String orderBy) {
-        switch (orderBy) {
-            case ASC_ORDER:
-                if (fetchStmtsAsc == null) {
-                    fetchStmtsAsc = initFetchStmt(orderBy);
-                }
-                return fetchStmtsAsc[aggType.ordinal()];
-            case DESC_ORDER:
-                if (fetchStmtsDesc == null) {
-                    fetchStmtsDesc = initFetchStmt(orderBy);
-                }
-                return fetchStmtsDesc[aggType.ordinal()];
-            default:
-                throw new RuntimeException("Not supported" + orderBy + "order!");
-        }
-    }
-
-    private PreparedStatement[] initFetchStmt(String orderBy) {
-        PreparedStatement[] fetchStmts = new PreparedStatement[Aggregation.values().length];
-        for (Aggregation type : Aggregation.values()) {
-            if (type == Aggregation.SUM && fetchStmts[Aggregation.AVG.ordinal()] != null) {
-                fetchStmts[type.ordinal()] = fetchStmts[Aggregation.AVG.ordinal()];
-            } else if (type == Aggregation.AVG && fetchStmts[Aggregation.SUM.ordinal()] != null) {
-                fetchStmts[type.ordinal()] = fetchStmts[Aggregation.SUM.ordinal()];
-            } else {
-                fetchStmts[type.ordinal()] = prepare(SELECT_PREFIX +
-                        String.join(", ", ModelConstants.getFetchColumnNames(type)) + " FROM " + ModelConstants.TS_KV_CF
-                        + " WHERE " + ModelConstants.ENTITY_TYPE_COLUMN + EQUALS_PARAM
-                        + "AND " + ModelConstants.ENTITY_ID_COLUMN + EQUALS_PARAM
-                        + "AND " + ModelConstants.KEY_COLUMN + EQUALS_PARAM
-                        + "AND " + ModelConstants.PARTITION_COLUMN + EQUALS_PARAM
-                        + "AND " + ModelConstants.TS_COLUMN + " > ? "
-                        + "AND " + ModelConstants.TS_COLUMN + " <= ?"
-                        + (type == Aggregation.NONE ? " ORDER BY " + ModelConstants.TS_COLUMN + " " + orderBy + " LIMIT ?" : ""));
-            }
-        }
-        return fetchStmts;
-    }
-
-    private PreparedStatement getLatestStmt() {
-        if (latestInsertStmt == null) {
-            latestInsertStmt = prepare(INSERT_INTO + ModelConstants.TS_KV_LATEST_CF +
-                    "(" + ModelConstants.ENTITY_TYPE_COLUMN +
-                    "," + ModelConstants.ENTITY_ID_COLUMN +
-                    "," + ModelConstants.KEY_COLUMN +
-                    "," + ModelConstants.TS_COLUMN +
-                    "," + ModelConstants.BOOLEAN_VALUE_COLUMN +
-                    "," + ModelConstants.STRING_VALUE_COLUMN +
-                    "," + ModelConstants.LONG_VALUE_COLUMN +
-                    "," + ModelConstants.DOUBLE_VALUE_COLUMN +
-                    "," + ModelConstants.JSON_VALUE_COLUMN + ")" +
-                    " VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)");
-        }
-        return latestInsertStmt;
-    }
-
-
     private PreparedStatement getPartitionInsertStmt() {
     private PreparedStatement getPartitionInsertStmt() {
         if (partitionInsertStmt == null) {
         if (partitionInsertStmt == null) {
             partitionInsertStmt = prepare(INSERT_INTO + ModelConstants.TS_KV_PARTITIONS_CF +
             partitionInsertStmt = prepare(INSERT_INTO + ModelConstants.TS_KV_PARTITIONS_CF +
@@ -873,42 +606,6 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         return partitionInsertTtlStmt;
         return partitionInsertTtlStmt;
     }
     }
 
 
-
-    private PreparedStatement getFindLatestStmt() {
-        if (findLatestStmt == null) {
-            findLatestStmt = prepare(SELECT_PREFIX +
-                    ModelConstants.KEY_COLUMN + "," +
-                    ModelConstants.TS_COLUMN + "," +
-                    ModelConstants.STRING_VALUE_COLUMN + "," +
-                    ModelConstants.BOOLEAN_VALUE_COLUMN + "," +
-                    ModelConstants.LONG_VALUE_COLUMN + "," +
-                    ModelConstants.DOUBLE_VALUE_COLUMN + "," +
-                    ModelConstants.JSON_VALUE_COLUMN + " " +
-                    "FROM " + ModelConstants.TS_KV_LATEST_CF + " " +
-                    "WHERE " + ModelConstants.ENTITY_TYPE_COLUMN + EQUALS_PARAM +
-                    "AND " + ModelConstants.ENTITY_ID_COLUMN + EQUALS_PARAM +
-                    "AND " + ModelConstants.KEY_COLUMN + EQUALS_PARAM);
-        }
-        return findLatestStmt;
-    }
-
-    private PreparedStatement getFindAllLatestStmt() {
-        if (findAllLatestStmt == null) {
-            findAllLatestStmt = prepare(SELECT_PREFIX +
-                    ModelConstants.KEY_COLUMN + "," +
-                    ModelConstants.TS_COLUMN + "," +
-                    ModelConstants.STRING_VALUE_COLUMN + "," +
-                    ModelConstants.BOOLEAN_VALUE_COLUMN + "," +
-                    ModelConstants.LONG_VALUE_COLUMN + "," +
-                    ModelConstants.DOUBLE_VALUE_COLUMN + "," +
-                    ModelConstants.JSON_VALUE_COLUMN + " " +
-                    "FROM " + ModelConstants.TS_KV_LATEST_CF + " " +
-                    "WHERE " + ModelConstants.ENTITY_TYPE_COLUMN + EQUALS_PARAM +
-                    "AND " + ModelConstants.ENTITY_ID_COLUMN + EQUALS_PARAM);
-        }
-        return findAllLatestStmt;
-    }
-
     private static String getColumnName(DataType type) {
     private static String getColumnName(DataType type) {
         switch (type) {
         switch (type) {
             case BOOLEAN:
             case BOOLEAN:
@@ -951,4 +648,56 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         }
         }
     }
     }
 
 
+    /**
+     //     * Select existing partitions from the table
+     //     * <code>{@link ModelConstants#TS_KV_PARTITIONS_CF}</code> for the given entity
+     //     */
+    private TbResultSetFuture fetchPartitions(TenantId tenantId, EntityId entityId, String key, long minPartition, long maxPartition) {
+        Select select = QueryBuilder.selectFrom(ModelConstants.TS_KV_PARTITIONS_CF).column(ModelConstants.PARTITION_COLUMN)
+                .whereColumn(ModelConstants.ENTITY_TYPE_COLUMN).isEqualTo(literal(entityId.getEntityType().name()))
+                .whereColumn(ModelConstants.ENTITY_ID_COLUMN).isEqualTo(literal(entityId.getId()))
+                .whereColumn(ModelConstants.KEY_COLUMN).isEqualTo(literal(key))
+                .whereColumn(ModelConstants.PARTITION_COLUMN).isGreaterThanOrEqualTo(literal(minPartition))
+                .whereColumn(ModelConstants.PARTITION_COLUMN).isLessThanOrEqualTo(literal(maxPartition));
+        return executeAsyncRead(tenantId, select.build());
+    }
+
+    private PreparedStatement getFetchStmt(Aggregation aggType, String orderBy) {
+        switch (orderBy) {
+            case ASC_ORDER:
+                if (fetchStmtsAsc == null) {
+                    fetchStmtsAsc = initFetchStmt(orderBy);
+                }
+                return fetchStmtsAsc[aggType.ordinal()];
+            case DESC_ORDER:
+                if (fetchStmtsDesc == null) {
+                    fetchStmtsDesc = initFetchStmt(orderBy);
+                }
+                return fetchStmtsDesc[aggType.ordinal()];
+            default:
+                throw new RuntimeException("Not supported" + orderBy + "order!");
+        }
+    }
+
+    private PreparedStatement[] initFetchStmt(String orderBy) {
+        PreparedStatement[] fetchStmts = new PreparedStatement[Aggregation.values().length];
+        for (Aggregation type : Aggregation.values()) {
+            if (type == Aggregation.SUM && fetchStmts[Aggregation.AVG.ordinal()] != null) {
+                fetchStmts[type.ordinal()] = fetchStmts[Aggregation.AVG.ordinal()];
+            } else if (type == Aggregation.AVG && fetchStmts[Aggregation.SUM.ordinal()] != null) {
+                fetchStmts[type.ordinal()] = fetchStmts[Aggregation.SUM.ordinal()];
+            } else {
+                fetchStmts[type.ordinal()] = prepare(SELECT_PREFIX +
+                        String.join(", ", ModelConstants.getFetchColumnNames(type)) + " FROM " + ModelConstants.TS_KV_CF
+                        + " WHERE " + ModelConstants.ENTITY_TYPE_COLUMN + EQUALS_PARAM
+                        + "AND " + ModelConstants.ENTITY_ID_COLUMN + EQUALS_PARAM
+                        + "AND " + ModelConstants.KEY_COLUMN + EQUALS_PARAM
+                        + "AND " + ModelConstants.PARTITION_COLUMN + EQUALS_PARAM
+                        + "AND " + ModelConstants.TS_COLUMN + " > ? "
+                        + "AND " + ModelConstants.TS_COLUMN + " <= ?"
+                        + (type == Aggregation.NONE ? " ORDER BY " + ModelConstants.TS_COLUMN + " " + orderBy + " LIMIT ?" : ""));
+            }
+        }
+        return fetchStmts;
+    }
 }
 }

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.dao.timeseries;
+
+import com.datastax.oss.driver.api.core.cql.BoundStatement;
+import com.datastax.oss.driver.api.core.cql.BoundStatementBuilder;
+import com.datastax.oss.driver.api.core.cql.PreparedStatement;
+import com.datastax.oss.driver.api.core.cql.Row;
+import com.datastax.oss.driver.api.core.cql.Statement;
+import com.datastax.oss.driver.api.querybuilder.QueryBuilder;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.kv.Aggregation;
+import org.thingsboard.server.common.data.kv.BaseReadTsKvQuery;
+import org.thingsboard.server.common.data.kv.BasicTsKvEntry;
+import org.thingsboard.server.common.data.kv.DeleteTsKvQuery;
+import org.thingsboard.server.common.data.kv.ReadTsKvQuery;
+import org.thingsboard.server.common.data.kv.StringDataEntry;
+import org.thingsboard.server.common.data.kv.TsKvEntry;
+import org.thingsboard.server.dao.model.ModelConstants;
+import org.thingsboard.server.dao.nosql.TbResultSet;
+import org.thingsboard.server.dao.sqlts.AggregationTimeseriesDao;
+import org.thingsboard.server.dao.util.NoSqlTsLatestDao;
+
+import javax.annotation.Nullable;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+
+import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.literal;
+
+@Component
+@Slf4j
+@NoSqlTsLatestDao
+public class CassandraBaseTimeseriesLatestDao extends AbstractCassandraBaseTimeseriesDao implements TimeseriesLatestDao {
+
+    @Autowired
+    protected AggregationTimeseriesDao aggregationTimeseriesDao;
+
+    private PreparedStatement latestInsertStmt;
+    private PreparedStatement findLatestStmt;
+    private PreparedStatement findAllLatestStmt;
+
+    @Override
+    public ListenableFuture<TsKvEntry> findLatest(TenantId tenantId, EntityId entityId, String key) {
+        BoundStatementBuilder stmtBuilder = new BoundStatementBuilder(getFindLatestStmt().bind());
+        stmtBuilder.setString(0, entityId.getEntityType().name());
+        stmtBuilder.setUuid(1, entityId.getId());
+        stmtBuilder.setString(2, key);
+        BoundStatement stmt = stmtBuilder.build();
+        log.debug(GENERATED_QUERY_FOR_ENTITY_TYPE_AND_ENTITY_ID, stmt, entityId.getEntityType(), entityId.getId());
+        return getFuture(executeAsyncRead(tenantId, stmt), rs -> convertResultToTsKvEntry(key, rs.one()));
+    }
+
+    @Override
+    public ListenableFuture<List<TsKvEntry>> findAllLatest(TenantId tenantId, EntityId entityId) {
+        BoundStatementBuilder stmtBuilder = new BoundStatementBuilder(getFindAllLatestStmt().bind());
+        stmtBuilder.setString(0, entityId.getEntityType().name());
+        stmtBuilder.setUuid(1, entityId.getId());
+        BoundStatement stmt = stmtBuilder.build();
+        log.debug(GENERATED_QUERY_FOR_ENTITY_TYPE_AND_ENTITY_ID, stmt, entityId.getEntityType(), entityId.getId());
+        return getFutureAsync(executeAsyncRead(tenantId, stmt), rs -> convertAsyncResultSetToTsKvEntryList(rs));
+    }
+
+    @Override
+    public ListenableFuture<Void> saveLatest(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry) {
+        BoundStatementBuilder stmtBuilder = new BoundStatementBuilder(getLatestStmt().bind());
+        stmtBuilder.setString(0, entityId.getEntityType().name())
+                .setUuid(1, entityId.getId())
+                .setString(2, tsKvEntry.getKey())
+                .setLong(3, tsKvEntry.getTs())
+                .set(4, tsKvEntry.getBooleanValue().orElse(null), Boolean.class)
+                .set(5, tsKvEntry.getStrValue().orElse(null), String.class)
+                .set(6, tsKvEntry.getLongValue().orElse(null), Long.class)
+                .set(7, tsKvEntry.getDoubleValue().orElse(null), Double.class);
+        Optional<String> jsonV = tsKvEntry.getJsonValue();
+        if (jsonV.isPresent()) {
+            stmtBuilder.setString(8, tsKvEntry.getJsonValue().get());
+        } else {
+            stmtBuilder.setToNull(8);
+        }
+        BoundStatement stmt = stmtBuilder.build();
+
+        return getFuture(executeAsyncWrite(tenantId, stmt), rs -> null);
+    }
+
+    @Override
+    public ListenableFuture<Void> removeLatest(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
+        ListenableFuture<TsKvEntry> latestEntryFuture = findLatest(tenantId, entityId, query.getKey());
+
+        ListenableFuture<Boolean> booleanFuture = Futures.transform(latestEntryFuture, latestEntry -> {
+            long ts = latestEntry.getTs();
+            if (ts > query.getStartTs() && ts <= query.getEndTs()) {
+                return true;
+            } else {
+                log.trace("Won't be deleted latest value for [{}], key - {}", entityId, query.getKey());
+            }
+            return false;
+        }, readResultsProcessingExecutor);
+
+        ListenableFuture<Void> removedLatestFuture = Futures.transformAsync(booleanFuture, isRemove -> {
+            if (isRemove) {
+                return deleteLatest(tenantId, entityId, query.getKey());
+            }
+            return Futures.immediateFuture(null);
+        }, readResultsProcessingExecutor);
+
+        final SimpleListenableFuture<Void> resultFuture = new SimpleListenableFuture<>();
+        Futures.addCallback(removedLatestFuture, new FutureCallback<Void>() {
+            @Override
+            public void onSuccess(@Nullable Void result) {
+                if (query.getRewriteLatestIfDeleted()) {
+                    ListenableFuture<Void> savedLatestFuture = Futures.transformAsync(booleanFuture, isRemove -> {
+                        if (isRemove) {
+                            return getNewLatestEntryFuture(tenantId, entityId, query);
+                        }
+                        return Futures.immediateFuture(null);
+                    }, readResultsProcessingExecutor);
+
+                    try {
+                        resultFuture.set(savedLatestFuture.get());
+                    } catch (InterruptedException | ExecutionException e) {
+                        log.warn("Could not get latest saved value for [{}], {}", entityId, query.getKey(), e);
+                    }
+                } else {
+                    resultFuture.set(null);
+                }
+            }
+
+            @Override
+            public void onFailure(Throwable t) {
+                log.warn("[{}] Failed to process remove of the latest value", entityId, t);
+            }
+        }, MoreExecutors.directExecutor());
+        return resultFuture;
+    }
+
+    private ListenableFuture<Void> getNewLatestEntryFuture(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query) {
+        long startTs = 0;
+        long endTs = query.getStartTs() - 1;
+        ReadTsKvQuery findNewLatestQuery = new BaseReadTsKvQuery(query.getKey(), startTs, endTs, endTs - startTs, 1,
+                Aggregation.NONE, DESC_ORDER);
+        ListenableFuture<List<TsKvEntry>> future = aggregationTimeseriesDao.findAllAsync(tenantId, entityId, findNewLatestQuery);
+
+        return Futures.transformAsync(future, entryList -> {
+            if (entryList.size() == 1) {
+                return saveLatest(tenantId, entityId, entryList.get(0));
+            } else {
+                log.trace("Could not find new latest value for [{}], key - {}", entityId, query.getKey());
+            }
+            return Futures.immediateFuture(null);
+        }, readResultsProcessingExecutor);
+    }
+
+    private ListenableFuture<Void> deleteLatest(TenantId tenantId, EntityId entityId, String key) {
+        Statement delete = QueryBuilder.deleteFrom(ModelConstants.TS_KV_LATEST_CF)
+                .whereColumn(ModelConstants.ENTITY_TYPE_COLUMN).isEqualTo(literal(entityId.getEntityType().name()))
+                .whereColumn(ModelConstants.ENTITY_ID_COLUMN).isEqualTo(literal(entityId.getId()))
+                .whereColumn(ModelConstants.KEY_COLUMN).isEqualTo(literal(key)).build();
+        log.debug("Remove request: {}", delete.toString());
+        return getFuture(executeAsyncWrite(tenantId, delete), rs -> null);
+    }
+
+    private ListenableFuture<List<TsKvEntry>> convertAsyncResultSetToTsKvEntryList(TbResultSet rs) {
+        return Futures.transform(rs.allRows(readResultsProcessingExecutor),
+                rows -> this.convertResultToTsKvEntryList(rows), readResultsProcessingExecutor);
+    }
+
+    private TsKvEntry convertResultToTsKvEntry(String key, Row row) {
+        if (row != null) {
+            long ts = row.getLong(ModelConstants.TS_COLUMN);
+            return new BasicTsKvEntry(ts, toKvEntry(row, key));
+        } else {
+            return new BasicTsKvEntry(System.currentTimeMillis(), new StringDataEntry(key, null));
+        }
+    }
+
+    private PreparedStatement getLatestStmt() {
+        if (latestInsertStmt == null) {
+            latestInsertStmt = prepare(INSERT_INTO + ModelConstants.TS_KV_LATEST_CF +
+                    "(" + ModelConstants.ENTITY_TYPE_COLUMN +
+                    "," + ModelConstants.ENTITY_ID_COLUMN +
+                    "," + ModelConstants.KEY_COLUMN +
+                    "," + ModelConstants.TS_COLUMN +
+                    "," + ModelConstants.BOOLEAN_VALUE_COLUMN +
+                    "," + ModelConstants.STRING_VALUE_COLUMN +
+                    "," + ModelConstants.LONG_VALUE_COLUMN +
+                    "," + ModelConstants.DOUBLE_VALUE_COLUMN +
+                    "," + ModelConstants.JSON_VALUE_COLUMN + ")" +
+                    " VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?)");
+        }
+        return latestInsertStmt;
+    }
+
+    private PreparedStatement getFindLatestStmt() {
+        if (findLatestStmt == null) {
+            findLatestStmt = prepare(SELECT_PREFIX +
+                    ModelConstants.KEY_COLUMN + "," +
+                    ModelConstants.TS_COLUMN + "," +
+                    ModelConstants.STRING_VALUE_COLUMN + "," +
+                    ModelConstants.BOOLEAN_VALUE_COLUMN + "," +
+                    ModelConstants.LONG_VALUE_COLUMN + "," +
+                    ModelConstants.DOUBLE_VALUE_COLUMN + "," +
+                    ModelConstants.JSON_VALUE_COLUMN + " " +
+                    "FROM " + ModelConstants.TS_KV_LATEST_CF + " " +
+                    "WHERE " + ModelConstants.ENTITY_TYPE_COLUMN + EQUALS_PARAM +
+                    "AND " + ModelConstants.ENTITY_ID_COLUMN + EQUALS_PARAM +
+                    "AND " + ModelConstants.KEY_COLUMN + EQUALS_PARAM);
+        }
+        return findLatestStmt;
+    }
+
+    private PreparedStatement getFindAllLatestStmt() {
+        if (findAllLatestStmt == null) {
+            findAllLatestStmt = prepare(SELECT_PREFIX +
+                    ModelConstants.KEY_COLUMN + "," +
+                    ModelConstants.TS_COLUMN + "," +
+                    ModelConstants.STRING_VALUE_COLUMN + "," +
+                    ModelConstants.BOOLEAN_VALUE_COLUMN + "," +
+                    ModelConstants.LONG_VALUE_COLUMN + "," +
+                    ModelConstants.DOUBLE_VALUE_COLUMN + "," +
+                    ModelConstants.JSON_VALUE_COLUMN + " " +
+                    "FROM " + ModelConstants.TS_KV_LATEST_CF + " " +
+                    "WHERE " + ModelConstants.ENTITY_TYPE_COLUMN + EQUALS_PARAM +
+                    "AND " + ModelConstants.ENTITY_ID_COLUMN + EQUALS_PARAM);
+        }
+        return findAllLatestStmt;
+    }
+}

@@ -31,19 +31,11 @@ public interface TimeseriesDao {
 
 
     ListenableFuture<List<TsKvEntry>> findAllAsync(TenantId tenantId, EntityId entityId, List<ReadTsKvQuery> queries);
     ListenableFuture<List<TsKvEntry>> findAllAsync(TenantId tenantId, EntityId entityId, List<ReadTsKvQuery> queries);
 
 
-    ListenableFuture<TsKvEntry> findLatest(TenantId tenantId, EntityId entityId, String key);
-
-    ListenableFuture<List<TsKvEntry>> findAllLatest(TenantId tenantId, EntityId entityId);
-
     ListenableFuture<Void> save(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry, long ttl);
     ListenableFuture<Void> save(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry, long ttl);
 
 
     ListenableFuture<Void> savePartition(TenantId tenantId, EntityId entityId, long tsKvEntryTs, String key, long ttl);
     ListenableFuture<Void> savePartition(TenantId tenantId, EntityId entityId, long tsKvEntryTs, String key, long ttl);
 
 
-    ListenableFuture<Void> saveLatest(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry);
-
     ListenableFuture<Void> remove(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query);
     ListenableFuture<Void> remove(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query);
 
 
-    ListenableFuture<Void> removeLatest(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query);
-
     ListenableFuture<Void> removePartition(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query);
     ListenableFuture<Void> removePartition(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query);
 }
 }

+/**
+ * Copyright © 2016-2020 The Thingsboard Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.thingsboard.server.dao.timeseries;
+
+import com.google.common.util.concurrent.ListenableFuture;
+import org.thingsboard.server.common.data.id.EntityId;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.kv.DeleteTsKvQuery;
+import org.thingsboard.server.common.data.kv.TsKvEntry;
+
+import java.util.List;
+
+public interface TimeseriesLatestDao {
+
+    ListenableFuture<TsKvEntry> findLatest(TenantId tenantId, EntityId entityId, String key);
+
+    ListenableFuture<List<TsKvEntry>> findAllLatest(TenantId tenantId, EntityId entityId);
+
+    ListenableFuture<Void> saveLatest(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry);
+
+    ListenableFuture<Void> removeLatest(TenantId tenantId, EntityId entityId, DeleteTsKvQuery query);
+
+}

+--
+-- Copyright © 2016-2020 The Thingsboard Authors
+--
+-- Licensed under the Apache License, Version 2.0 (the "License");
+-- you may not use this file except in compliance with the License.
+-- You may obtain a copy of the License at
+--
+--     http://www.apache.org/licenses/LICENSE-2.0
+--
+-- Unless required by applicable law or agreed to in writing, software
+-- distributed under the License is distributed on an "AS IS" BASIS,
+-- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+-- See the License for the specific language governing permissions and
+-- limitations under the License.
+--
+
+CREATE KEYSPACE IF NOT EXISTS thingsboard
+WITH replication = {
+	'class' : 'SimpleStrategy',
+	'replication_factor' : 1
+};
+
+CREATE TABLE IF NOT EXISTS thingsboard.ts_kv_latest_cf (
+    entity_type text, // (DEVICE, CUSTOMER, TENANT)
+    entity_id timeuuid,
+    key text,
+    ts bigint,
+    bool_v boolean,
+    str_v text,
+    long_v bigint,
+    dbl_v double,
+    json_v text,
+    PRIMARY KEY (( entity_type, entity_id ), key)
+) WITH compaction = { 'class' :  'LeveledCompactionStrategy'  };

@@ -42,16 +42,3 @@ CREATE TABLE IF NOT EXISTS thingsboard.ts_kv_partitions_cf (
     PRIMARY KEY (( entity_type, entity_id, key ), partition)
     PRIMARY KEY (( entity_type, entity_id, key ), partition)
 ) WITH CLUSTERING ORDER BY ( partition ASC )
 ) WITH CLUSTERING ORDER BY ( partition ASC )
   AND compaction = { 'class' :  'LeveledCompactionStrategy'  };
   AND compaction = { 'class' :  'LeveledCompactionStrategy'  };
-
-CREATE TABLE IF NOT EXISTS thingsboard.ts_kv_latest_cf (
-    entity_type text, // (DEVICE, CUSTOMER, TENANT)
-    entity_id timeuuid,
-    key text,
-    ts bigint,
-    bool_v boolean,
-    str_v text,
-    long_v bigint,
-    dbl_v double,
-    json_v text,
-    PRIMARY KEY (( entity_type, entity_id ), key)
-) WITH compaction = { 'class' :  'LeveledCompactionStrategy'  };

@@ -272,3 +272,20 @@ CREATE TABLE IF NOT EXISTS entity_view (
     additional_info varchar
     additional_info varchar
 );
 );
 
 
+CREATE TABLE IF NOT EXISTS ts_kv_latest (
+    entity_id uuid NOT NULL,
+    key int NOT NULL,
+    ts bigint NOT NULL,
+    bool_v boolean,
+    str_v varchar(10000000),
+    long_v bigint,
+    dbl_v double precision,
+    json_v varchar(10000000),
+    CONSTRAINT ts_kv_latest_pkey PRIMARY KEY (entity_id, key)
+);
+
+CREATE TABLE IF NOT EXISTS ts_kv_dictionary (
+    key varchar(255) NOT NULL,
+    key_id int GENERATED BY DEFAULT AS IDENTITY(start with 0 increment by 1) UNIQUE,
+    CONSTRAINT ts_key_id_pkey PRIMARY KEY (key)
+);

@@ -14,6 +14,13 @@
 -- limitations under the License.
 -- limitations under the License.
 --
 --
 
 
+CREATE TABLE IF NOT EXISTS tb_schema_settings
+(
+    schema_version bigint NOT NULL,
+    CONSTRAINT tb_schema_settings_pkey PRIMARY KEY (schema_version)
+);
+
+INSERT INTO tb_schema_settings (schema_version) VALUES (3001000) ON CONFLICT (schema_version) DO UPDATE SET schema_version = 3001000;
 
 
 CREATE TABLE IF NOT EXISTS admin_settings (
 CREATE TABLE IF NOT EXISTS admin_settings (
     id uuid NOT NULL CONSTRAINT admin_settings_pkey PRIMARY KEY,
     id uuid NOT NULL CONSTRAINT admin_settings_pkey PRIMARY KEY,
@@ -331,3 +338,4 @@ BEGIN
                '-' || substring(entity_id, 16, 4) || '-' || substring(entity_id, 20, 12);
                '-' || substring(entity_id, 16, 4) || '-' || substring(entity_id, 20, 12);
 END;
 END;
 $$ LANGUAGE plpgsql;
 $$ LANGUAGE plpgsql;
+

@@ -46,14 +46,6 @@ CREATE TABLE IF NOT EXISTS ts_kv_latest (
     CONSTRAINT ts_kv_latest_pkey PRIMARY KEY (entity_id, key)
     CONSTRAINT ts_kv_latest_pkey PRIMARY KEY (entity_id, key)
 );
 );
 
 
-CREATE TABLE IF NOT EXISTS tb_schema_settings
-(
-    schema_version bigint NOT NULL,
-    CONSTRAINT tb_schema_settings_pkey PRIMARY KEY (schema_version)
-);
-
-INSERT INTO tb_schema_settings (schema_version) VALUES (2005001) ON CONFLICT (schema_version) DO UPDATE SET schema_version = 2005001;
-
 CREATE OR REPLACE FUNCTION to_uuid(IN entity_id varchar, OUT uuid_id uuid) AS
 CREATE OR REPLACE FUNCTION to_uuid(IN entity_id varchar, OUT uuid_id uuid) AS
 $$
 $$
 BEGIN
 BEGIN

@@ -28,18 +28,6 @@ CREATE TABLE IF NOT EXISTS ts_kv (
     CONSTRAINT ts_kv_pkey PRIMARY KEY (entity_id, key, ts)
     CONSTRAINT ts_kv_pkey PRIMARY KEY (entity_id, key, ts)
 );
 );
 
 
-CREATE TABLE IF NOT EXISTS ts_kv_latest (
-    entity_id uuid NOT NULL,
-    key int NOT NULL,
-    ts bigint NOT NULL,
-    bool_v boolean,
-    str_v varchar(10000000),
-    long_v bigint,
-    dbl_v double precision,
-    json_v varchar(10000000),
-    CONSTRAINT ts_kv_latest_pkey PRIMARY KEY (entity_id, key)
-);
-
 CREATE TABLE IF NOT EXISTS ts_kv_dictionary (
 CREATE TABLE IF NOT EXISTS ts_kv_dictionary (
     key varchar(255) NOT NULL,
     key varchar(255) NOT NULL,
     key_id int GENERATED BY DEFAULT AS IDENTITY(start with 0 increment by 1) UNIQUE,
     key_id int GENERATED BY DEFAULT AS IDENTITY(start with 0 increment by 1) UNIQUE,

@@ -27,19 +27,6 @@ CREATE TABLE IF NOT EXISTS ts_kv
     CONSTRAINT ts_kv_pkey PRIMARY KEY (entity_id, key, ts)
     CONSTRAINT ts_kv_pkey PRIMARY KEY (entity_id, key, ts)
 ) PARTITION BY RANGE (ts);
 ) PARTITION BY RANGE (ts);
 
 
-CREATE TABLE IF NOT EXISTS ts_kv_latest
-(
-    entity_id uuid   NOT NULL,
-    key       int    NOT NULL,
-    ts        bigint NOT NULL,
-    bool_v    boolean,
-    str_v     varchar(10000000),
-    long_v    bigint,
-    dbl_v     double precision,
-    json_v    json,
-    CONSTRAINT ts_kv_latest_pkey PRIMARY KEY (entity_id, key)
-);
-
 CREATE TABLE IF NOT EXISTS ts_kv_dictionary
 CREATE TABLE IF NOT EXISTS ts_kv_dictionary
 (
 (
     key    varchar(255) NOT NULL,
     key    varchar(255) NOT NULL,
@@ -47,14 +34,6 @@ CREATE TABLE IF NOT EXISTS ts_kv_dictionary
     CONSTRAINT ts_key_id_pkey PRIMARY KEY (key)
     CONSTRAINT ts_key_id_pkey PRIMARY KEY (key)
 );
 );
 
 
-CREATE TABLE IF NOT EXISTS tb_schema_settings
-(
-    schema_version bigint NOT NULL,
-    CONSTRAINT tb_schema_settings_pkey PRIMARY KEY (schema_version)
-);
-
-INSERT INTO tb_schema_settings (schema_version) VALUES (2005001) ON CONFLICT (schema_version) DO UPDATE SET schema_version = 2005001;
-
 CREATE OR REPLACE PROCEDURE drop_partitions_by_max_ttl(IN partition_type varchar, IN system_ttl bigint, INOUT deleted bigint)
 CREATE OR REPLACE PROCEDURE drop_partitions_by_max_ttl(IN partition_type varchar, IN system_ttl bigint, INOUT deleted bigint)
     LANGUAGE plpgsql AS
     LANGUAGE plpgsql AS
 $$
 $$

@@ -22,7 +22,6 @@ import org.dbunit.ext.hsqldb.HsqldbDataTypeFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.annotation.Configuration;
-import org.thingsboard.server.dao.util.SqlDao;
 
 
 import javax.sql.DataSource;
 import javax.sql.DataSource;
 import java.io.IOException;
 import java.io.IOException;
@@ -32,7 +31,6 @@ import java.sql.SQLException;
  * Created by Valerii Sosliuk on 5/6/2017.
  * Created by Valerii Sosliuk on 5/6/2017.
  */
  */
 @Configuration
 @Configuration
-@SqlDao
 public class JpaDbunitTestConfig {
 public class JpaDbunitTestConfig {
 
 
     @Autowired
     @Autowired

@@ -40,7 +40,8 @@ public class NoSqlDaoServiceTestSuite {
     public static CustomCassandraCQLUnit cassandraUnit =
     public static CustomCassandraCQLUnit cassandraUnit =
             new CustomCassandraCQLUnit(
             new CustomCassandraCQLUnit(
                     Arrays.asList(
                     Arrays.asList(
-                            new ClassPathCQLDataSet("cassandra/schema-ts.cql", false, false)
+                            new ClassPathCQLDataSet("cassandra/schema-ts.cql", false, false),
+                            new ClassPathCQLDataSet("cassandra/schema-ts-latest.cql", false, false)
                     ),
                     ),
                     "cassandra-test.yaml", 30000L);
                     "cassandra-test.yaml", 30000L);
 
 

 database.ts.type=cassandra
 database.ts.type=cassandra
+database.ts_latest.type=cassandra
 
 
 sql.ts_inserts_executor_type=fixed
 sql.ts_inserts_executor_type=fixed
 sql.ts_inserts_fixed_thread_pool_size=10
 sql.ts_inserts_fixed_thread_pool_size=10

 database.ts.type=sql
 database.ts.type=sql
+database.ts_latest.type=sql
 
 
 sql.ts_inserts_executor_type=fixed
 sql.ts_inserts_executor_type=fixed
 sql.ts_inserts_fixed_thread_pool_size=200
 sql.ts_inserts_fixed_thread_pool_size=200