Merge branch 'develop/3.0' of https://github.com/thingsboard/thingsboard into map/3.0

@@ -111,6 +111,10 @@
                     <groupId>org.slf4j</groupId>
                     <groupId>org.slf4j</groupId>
                     <artifactId>slf4j-log4j12</artifactId>
                     <artifactId>slf4j-log4j12</artifactId>
                 </exclusion>
                 </exclusion>
+                <exclusion>
+                    <groupId>org.hibernate</groupId>
+                    <artifactId>hibernate-validator</artifactId>
+                </exclusion>
             </exclusions>
             </exclusions>
             <scope>test</scope>
             <scope>test</scope>
         </dependency>
         </dependency>
@@ -241,6 +245,12 @@
             <groupId>org.springframework.boot</groupId>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-test</artifactId>
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
             <scope>test</scope>
+            <exclusions>
+                <exclusion>
+                    <groupId>com.vaadin.external.google</groupId>
+                    <artifactId>android-json</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
         </dependency>
         <dependency>
         <dependency>
             <groupId>org.springframework.security</groupId>
             <groupId>org.springframework.security</groupId>

@@ -164,25 +164,24 @@ BEGIN
 END;
 END;
 $$;
 $$;
 
 
--- call insert_into_ts_kv();
+CREATE OR REPLACE FUNCTION to_uuid(IN entity_id varchar, OUT uuid_id uuid) AS
+$$
+BEGIN
+    uuid_id := substring(entity_id, 8, 8) || '-' || substring(entity_id, 4, 4) || '-1' || substring(entity_id, 1, 3) ||
+               '-' || substring(entity_id, 16, 4) || '-' || substring(entity_id, 20, 12);
+END;
+$$ LANGUAGE plpgsql;
 
 
-CREATE OR REPLACE PROCEDURE insert_into_ts_kv() LANGUAGE plpgsql AS $$
-DECLARE
-    insert_size CONSTANT integer := 10000;
-    insert_counter       integer DEFAULT 0;
-    insert_record        RECORD;
-    insert_cursor CURSOR FOR SELECT CONCAT(entity_id_uuid_first_part, '-', entity_id_uuid_second_part, '-1', entity_id_uuid_third_part, '-', entity_id_uuid_fourth_part, '-', entity_id_uuid_fifth_part)::uuid AS entity_id,
+CREATE OR REPLACE PROCEDURE insert_into_ts_kv(IN path_to_file varchar) LANGUAGE plpgsql AS $$
+BEGIN
+    EXECUTE format ('COPY (SELECT to_uuid(entity_id)                                                          AS entity_id,
                                     ts_kv_records.key                                                         AS key,
                                     ts_kv_records.key                                                         AS key,
                                     ts_kv_records.ts                                                          AS ts,
                                     ts_kv_records.ts                                                          AS ts,
                                     ts_kv_records.bool_v                                                      AS bool_v,
                                     ts_kv_records.bool_v                                                      AS bool_v,
                                     ts_kv_records.str_v                                                       AS str_v,
                                     ts_kv_records.str_v                                                       AS str_v,
                                     ts_kv_records.long_v                                                      AS long_v,
                                     ts_kv_records.long_v                                                      AS long_v,
                                     ts_kv_records.dbl_v                                                       AS dbl_v
                                     ts_kv_records.dbl_v                                                       AS dbl_v
-                             FROM (SELECT SUBSTRING(entity_id, 8, 8)  AS entity_id_uuid_first_part,
-                                          SUBSTRING(entity_id, 4, 4)  AS entity_id_uuid_second_part,
-                                          SUBSTRING(entity_id, 1, 3)  AS entity_id_uuid_third_part,
-                                          SUBSTRING(entity_id, 16, 4) AS entity_id_uuid_fourth_part,
-                                          SUBSTRING(entity_id, 20)    AS entity_id_uuid_fifth_part,
+                             FROM (SELECT entity_id                   AS entity_id,
                                           key_id                      AS key,
                                           key_id                      AS key,
                                           ts,
                                           ts,
                                           bool_v,
                                           bool_v,
@@ -190,46 +189,23 @@ DECLARE
                                           long_v,
                                           long_v,
                                           dbl_v
                                           dbl_v
                                    FROM ts_kv_old
                                    FROM ts_kv_old
-                                            INNER JOIN ts_kv_dictionary ON (ts_kv_old.key = ts_kv_dictionary.key)) AS ts_kv_records;
-BEGIN
-    OPEN insert_cursor;
-    LOOP
-        insert_counter := insert_counter + 1;
-        FETCH insert_cursor INTO insert_record;
-        IF NOT FOUND THEN
-            RAISE NOTICE '% records have been inserted into the partitioned ts_kv!',insert_counter - 1;
-            EXIT;
-        END IF;
-        INSERT INTO ts_kv(entity_id, key, ts, bool_v, str_v, long_v, dbl_v)
-        VALUES (insert_record.entity_id, insert_record.key, insert_record.ts, insert_record.bool_v, insert_record.str_v,
-                insert_record.long_v, insert_record.dbl_v);
-        IF MOD(insert_counter, insert_size) = 0 THEN
-            RAISE NOTICE '% records have been inserted into the partitioned ts_kv!',insert_counter;
-        END IF;
-    END LOOP;
-    CLOSE insert_cursor;
-END;
+                                            INNER JOIN ts_kv_dictionary ON (ts_kv_old.key = ts_kv_dictionary.key)) AS ts_kv_records) TO %L;', path_to_file);
+    EXECUTE format ('COPY ts_kv FROM %L', path_to_file);
+END
 $$;
 $$;
 
 
 -- call insert_into_ts_kv_latest();
 -- call insert_into_ts_kv_latest();
 
 
-CREATE OR REPLACE PROCEDURE insert_into_ts_kv_latest() LANGUAGE plpgsql AS $$
-DECLARE
-    insert_size CONSTANT integer := 10000;
-    insert_counter       integer DEFAULT 0;
-    insert_record        RECORD;
-    insert_cursor CURSOR FOR SELECT CONCAT(entity_id_uuid_first_part, '-', entity_id_uuid_second_part, '-1', entity_id_uuid_third_part, '-', entity_id_uuid_fourth_part, '-', entity_id_uuid_fifth_part)::uuid AS entity_id,
+CREATE OR REPLACE PROCEDURE insert_into_ts_kv_latest(IN path_to_file varchar) LANGUAGE plpgsql AS $$
+BEGIN
+    EXECUTE format ('COPY (SELECT to_uuid(entity_id)      	                                                     AS entity_id,
                                     ts_kv_latest_records.key                                                         AS key,
                                     ts_kv_latest_records.key                                                         AS key,
                                     ts_kv_latest_records.ts                                                          AS ts,
                                     ts_kv_latest_records.ts                                                          AS ts,
                                     ts_kv_latest_records.bool_v                                                      AS bool_v,
                                     ts_kv_latest_records.bool_v                                                      AS bool_v,
                                     ts_kv_latest_records.str_v                                                       AS str_v,
                                     ts_kv_latest_records.str_v                                                       AS str_v,
                                     ts_kv_latest_records.long_v                                                      AS long_v,
                                     ts_kv_latest_records.long_v                                                      AS long_v,
                                     ts_kv_latest_records.dbl_v                                                       AS dbl_v
                                     ts_kv_latest_records.dbl_v                                                       AS dbl_v
-                             FROM (SELECT SUBSTRING(entity_id, 8, 8)  AS entity_id_uuid_first_part,
-                                          SUBSTRING(entity_id, 4, 4)  AS entity_id_uuid_second_part,
-                                          SUBSTRING(entity_id, 1, 3)  AS entity_id_uuid_third_part,
-                                          SUBSTRING(entity_id, 16, 4) AS entity_id_uuid_fourth_part,
-                                          SUBSTRING(entity_id, 20)    AS entity_id_uuid_fifth_part,
+                             FROM (SELECT entity_id                   AS entity_id,
                                           key_id                      AS key,
                                           key_id                      AS key,
                                           ts,
                                           ts,
                                           bool_v,
                                           bool_v,
@@ -237,24 +213,8 @@ DECLARE
                                           long_v,
                                           long_v,
                                           dbl_v
                                           dbl_v
                                    FROM ts_kv_latest_old
                                    FROM ts_kv_latest_old
-                                            INNER JOIN ts_kv_dictionary ON (ts_kv_latest_old.key = ts_kv_dictionary.key)) AS ts_kv_latest_records;
-BEGIN
-    OPEN insert_cursor;
-    LOOP
-        insert_counter := insert_counter + 1;
-        FETCH insert_cursor INTO insert_record;
-        IF NOT FOUND THEN
-            RAISE NOTICE '% records have been inserted into the ts_kv_latest!',insert_counter - 1;
-            EXIT;
-        END IF;
-        INSERT INTO ts_kv_latest(entity_id, key, ts, bool_v, str_v, long_v, dbl_v)
-        VALUES (insert_record.entity_id, insert_record.key, insert_record.ts, insert_record.bool_v, insert_record.str_v,
-                insert_record.long_v, insert_record.dbl_v);
-        IF MOD(insert_counter, insert_size) = 0 THEN
-            RAISE NOTICE '% records have been inserted into the ts_kv_latest!',insert_counter;
-        END IF;
-    END LOOP;
-    CLOSE insert_cursor;
+                                            INNER JOIN ts_kv_dictionary ON (ts_kv_latest_old.key = ts_kv_dictionary.key)) AS ts_kv_latest_records) TO %L;', path_to_file);
+    EXECUTE format ('COPY ts_kv_latest FROM %L', path_to_file);
 END;
 END;
 $$;
 $$;
 
 

@@ -96,51 +96,36 @@ BEGIN
 END;
 END;
 $$;
 $$;
 
 
--- call insert_into_ts_kv();
+CREATE OR REPLACE FUNCTION to_uuid(IN entity_id varchar, OUT uuid_id uuid) AS
+$$
+BEGIN
+    uuid_id := substring(entity_id, 8, 8) || '-' || substring(entity_id, 4, 4) || '-1' || substring(entity_id, 1, 3) ||
+               '-' || substring(entity_id, 16, 4) || '-' || substring(entity_id, 20, 12);
+END;
+$$ LANGUAGE plpgsql;
 
 
-CREATE OR REPLACE PROCEDURE insert_into_ts_kv() LANGUAGE plpgsql AS $$
+-- call insert_into_ts_kv();
 
 
-DECLARE
-    insert_size CONSTANT integer := 10000;
-    insert_counter       integer DEFAULT 0;
-    insert_record        RECORD;
-    insert_cursor CURSOR FOR SELECT CONCAT(entity_id_uuid_first_part, '-', entity_id_uuid_second_part, '-1', entity_id_uuid_third_part, '-', entity_id_uuid_fourth_part, '-', entity_id_uuid_fifth_part)::uuid AS entity_id,
-                                    new_ts_kv_records.key                                                         AS key,
-                                    new_ts_kv_records.ts                                                          AS ts,
-                                    new_ts_kv_records.bool_v                                                      AS bool_v,
-                                    new_ts_kv_records.str_v                                                       AS str_v,
-                                    new_ts_kv_records.long_v                                                      AS long_v,
-                                    new_ts_kv_records.dbl_v                                                       AS dbl_v
-                             FROM (SELECT SUBSTRING(entity_id, 8, 8)  AS entity_id_uuid_first_part,
-                                          SUBSTRING(entity_id, 4, 4)  AS entity_id_uuid_second_part,
-                                          SUBSTRING(entity_id, 1, 3)  AS entity_id_uuid_third_part,
-                                          SUBSTRING(entity_id, 16, 4) AS entity_id_uuid_fourth_part,
-                                          SUBSTRING(entity_id, 20)    AS entity_id_uuid_fifth_part,
-                                          key_id                      AS key,
-                                          ts,
-                                          bool_v,
-                                          str_v,
-                                          long_v,
-                                          dbl_v
-                                   FROM tenant_ts_kv_old
-                                            INNER JOIN ts_kv_dictionary ON (tenant_ts_kv_old.key = ts_kv_dictionary.key)) AS new_ts_kv_records;
+CREATE OR REPLACE PROCEDURE insert_into_ts_kv(IN path_to_file varchar) LANGUAGE plpgsql AS $$
 BEGIN
 BEGIN
-    OPEN insert_cursor;
-    LOOP
-        insert_counter := insert_counter + 1;
-        FETCH insert_cursor INTO insert_record;
-        IF NOT FOUND THEN
-            RAISE NOTICE '% records have been inserted into the new ts_kv table!',insert_counter - 1;
-            EXIT;
-        END IF;
-        INSERT INTO ts_kv(entity_id, key, ts, bool_v, str_v, long_v, dbl_v)
-        VALUES (insert_record.entity_id, insert_record.key, insert_record.ts, insert_record.bool_v, insert_record.str_v,
-                insert_record.long_v, insert_record.dbl_v);
-        IF MOD(insert_counter, insert_size) = 0 THEN
-            RAISE NOTICE '% records have been inserted into the new ts_kv table!',insert_counter;
-        END IF;
-    END LOOP;
-    CLOSE insert_cursor;
+
+    EXECUTE format ('COPY (SELECT to_uuid(entity_id)                                     AS entity_id,
+           new_ts_kv_records.key                                                         AS key,
+           new_ts_kv_records.ts                                                          AS ts,
+           new_ts_kv_records.bool_v                                                      AS bool_v,
+           new_ts_kv_records.str_v                                                       AS str_v,
+           new_ts_kv_records.long_v                                                      AS long_v,
+           new_ts_kv_records.dbl_v                                                       AS dbl_v
+    FROM (SELECT entity_id                   AS entity_id,
+                 key_id                      AS key,
+                 ts,
+                 bool_v,
+                 str_v,
+                 long_v,
+                 dbl_v
+          FROM tenant_ts_kv_old
+                   INNER JOIN ts_kv_dictionary ON (tenant_ts_kv_old.key = ts_kv_dictionary.key)) AS new_ts_kv_records) TO %L;', path_to_file);
+    EXECUTE format ('COPY ts_kv FROM %L', path_to_file);
 END;
 END;
 $$;
 $$;
 
 

@@ -16,7 +16,6 @@
 package org.thingsboard.server.actors.ruleChain;
 package org.thingsboard.server.actors.ruleChain;
 
 
 import akka.actor.ActorRef;
 import akka.actor.ActorRef;
-import com.datastax.driver.core.ResultSetFuture;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.netty.channel.EventLoopGroup;
 import io.netty.channel.EventLoopGroup;
@@ -53,6 +52,7 @@ import org.thingsboard.server.dao.dashboard.DashboardService;
 import org.thingsboard.server.dao.device.DeviceService;
 import org.thingsboard.server.dao.device.DeviceService;
 import org.thingsboard.server.dao.entityview.EntityViewService;
 import org.thingsboard.server.dao.entityview.EntityViewService;
 import org.thingsboard.server.dao.nosql.CassandraStatementTask;
 import org.thingsboard.server.dao.nosql.CassandraStatementTask;
+import org.thingsboard.server.dao.nosql.TbResultSetFuture;
 import org.thingsboard.server.dao.relation.RelationService;
 import org.thingsboard.server.dao.relation.RelationService;
 import org.thingsboard.server.dao.rule.RuleChainService;
 import org.thingsboard.server.dao.rule.RuleChainService;
 import org.thingsboard.server.dao.tenant.TenantService;
 import org.thingsboard.server.dao.tenant.TenantService;
@@ -405,7 +405,7 @@ class DefaultTbContext implements TbContext {
     }
     }
 
 
     @Override
     @Override
-    public ResultSetFuture submitCassandraTask(CassandraStatementTask task) {
+    public TbResultSetFuture submitCassandraTask(CassandraStatementTask task) {
         return mainCtx.getCassandraBufferedRateExecutor().submit(task);
         return mainCtx.getCassandraBufferedRateExecutor().submit(task);
     }
     }
 
 

@@ -15,7 +15,6 @@
  */
  */
 package org.thingsboard.server.controller;
 package org.thingsboard.server.controller;
 
 
-import com.datastax.driver.core.utils.UUIDs;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectMapper;

@@ -34,6 +34,9 @@ public abstract class AbstractSqlTsDatabaseUpgradeService {
     protected static final String CALL_REGEX = "call ";
     protected static final String CALL_REGEX = "call ";
     protected static final String DROP_TABLE = "DROP TABLE ";
     protected static final String DROP_TABLE = "DROP TABLE ";
     protected static final String DROP_PROCEDURE_IF_EXISTS = "DROP PROCEDURE IF EXISTS ";
     protected static final String DROP_PROCEDURE_IF_EXISTS = "DROP PROCEDURE IF EXISTS ";
+    protected static final String TS_KV_SQL = "ts_kv.sql";
+    protected static final String PATH_TO_USERS_PUBLIC_FOLDER = "C:\\Users\\Public";
+    protected static final String THINGSBOARD_WINDOWS_UPGRADE_DIR = "THINGSBOARD_WINDOWS_UPGRADE_DIR";
 
 
     @Value("${spring.datasource.url}")
     @Value("${spring.datasource.url}")
     protected String dbUrl;
     protected String dbUrl;

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.service.install;
 package org.thingsboard.server.service.install;
 
 
-import com.datastax.driver.core.exceptions.InvalidQueryException;
+import com.datastax.oss.driver.api.core.servererrors.InvalidQueryException;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.context.annotation.Profile;
 import org.springframework.context.annotation.Profile;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;

@@ -16,12 +16,17 @@
 package org.thingsboard.server.service.install;
 package org.thingsboard.server.service.install;
 
 
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.SystemUtils;
 import org.springframework.beans.factory.annotation.Value;
 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.util.PsqlDao;
 import org.thingsboard.server.dao.util.PsqlDao;
 import org.thingsboard.server.dao.util.SqlTsDao;
 import org.thingsboard.server.dao.util.SqlTsDao;
 
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.Paths;
 import java.sql.Connection;
 import java.sql.Connection;
@@ -37,6 +42,7 @@ public class PsqlTsDatabaseUpgradeService extends AbstractSqlTsDatabaseUpgradeSe
     @Value("${sql.postgres.ts_key_value_partitioning:MONTHS}")
     @Value("${sql.postgres.ts_key_value_partitioning:MONTHS}")
     private String partitionType;
     private String partitionType;
 
 
+    private static final String TS_KV_LATEST_SQL = "ts_kv_latest.sql";
     private static final String LOAD_FUNCTIONS_SQL = "schema_update_psql_ts.sql";
     private static final String LOAD_FUNCTIONS_SQL = "schema_update_psql_ts.sql";
     private static final String LOAD_TTL_FUNCTIONS_SQL = "schema_update_ttl.sql";
     private static final String LOAD_TTL_FUNCTIONS_SQL = "schema_update_ttl.sql";
     private static final String LOAD_DROP_PARTITIONS_FUNCTIONS_SQL = "schema_update_psql_drop_partitions.sql";
     private static final String LOAD_DROP_PARTITIONS_FUNCTIONS_SQL = "schema_update_psql_drop_partitions.sql";
@@ -49,15 +55,13 @@ public class PsqlTsDatabaseUpgradeService extends AbstractSqlTsDatabaseUpgradeSe
     private static final String CREATE_PARTITIONS = "create_partitions(IN partition_type varchar)";
     private static final String CREATE_PARTITIONS = "create_partitions(IN partition_type varchar)";
     private static final String CREATE_TS_KV_DICTIONARY_TABLE = "create_ts_kv_dictionary_table()";
     private static final String CREATE_TS_KV_DICTIONARY_TABLE = "create_ts_kv_dictionary_table()";
     private static final String INSERT_INTO_DICTIONARY = "insert_into_dictionary()";
     private static final String INSERT_INTO_DICTIONARY = "insert_into_dictionary()";
-    private static final String INSERT_INTO_TS_KV = "insert_into_ts_kv()";
-    private static final String INSERT_INTO_TS_KV_LATEST = "insert_into_ts_kv_latest()";
+    private static final String INSERT_INTO_TS_KV = "insert_into_ts_kv(IN path_to_file varchar)";
+    private static final String INSERT_INTO_TS_KV_LATEST = "insert_into_ts_kv_latest(IN path_to_file varchar)";
 
 
     private static final String CALL_CREATE_PARTITION_TS_KV_TABLE = CALL_REGEX + CREATE_PARTITION_TS_KV_TABLE;
     private static final String CALL_CREATE_PARTITION_TS_KV_TABLE = CALL_REGEX + CREATE_PARTITION_TS_KV_TABLE;
     private static final String CALL_CREATE_NEW_TS_KV_LATEST_TABLE = CALL_REGEX + CREATE_NEW_TS_KV_LATEST_TABLE;
     private static final String CALL_CREATE_NEW_TS_KV_LATEST_TABLE = CALL_REGEX + CREATE_NEW_TS_KV_LATEST_TABLE;
     private static final String CALL_CREATE_TS_KV_DICTIONARY_TABLE = CALL_REGEX + CREATE_TS_KV_DICTIONARY_TABLE;
     private static final String CALL_CREATE_TS_KV_DICTIONARY_TABLE = CALL_REGEX + CREATE_TS_KV_DICTIONARY_TABLE;
     private static final String CALL_INSERT_INTO_DICTIONARY = CALL_REGEX + INSERT_INTO_DICTIONARY;
     private static final String CALL_INSERT_INTO_DICTIONARY = CALL_REGEX + INSERT_INTO_DICTIONARY;
-    private static final String CALL_INSERT_INTO_TS_KV = CALL_REGEX + INSERT_INTO_TS_KV;
-    private static final String CALL_INSERT_INTO_TS_KV_LATEST = CALL_REGEX + INSERT_INTO_TS_KV_LATEST;
 
 
     private static final String DROP_TABLE_TS_KV_OLD = DROP_TABLE + TS_KV_OLD;
     private static final String DROP_TABLE_TS_KV_OLD = DROP_TABLE + TS_KV_OLD;
     private static final String DROP_TABLE_TS_KV_LATEST_OLD = DROP_TABLE + TS_KV_LATEST_OLD;
     private static final String DROP_TABLE_TS_KV_LATEST_OLD = DROP_TABLE + TS_KV_LATEST_OLD;
@@ -94,9 +98,58 @@ public class PsqlTsDatabaseUpgradeService extends AbstractSqlTsDatabaseUpgradeSe
                             }
                             }
                             executeQuery(conn, CALL_CREATE_TS_KV_DICTIONARY_TABLE);
                             executeQuery(conn, CALL_CREATE_TS_KV_DICTIONARY_TABLE);
                             executeQuery(conn, CALL_INSERT_INTO_DICTIONARY);
                             executeQuery(conn, CALL_INSERT_INTO_DICTIONARY);
-                            executeQuery(conn, CALL_INSERT_INTO_TS_KV);
-                            executeQuery(conn, CALL_CREATE_NEW_TS_KV_LATEST_TABLE);
-                            executeQuery(conn, CALL_INSERT_INTO_TS_KV_LATEST);
+
+                            Path pathToTempTsKvFile;
+                            Path pathToTempTsKvLatestFile;
+                            if (SystemUtils.IS_OS_WINDOWS) {
+                                log.info("Lookup for environment variable: {} ...", THINGSBOARD_WINDOWS_UPGRADE_DIR);
+                                Path pathToDir;
+                                String thingsboardWindowsUpgradeDir = System.getenv("THINGSBOARD_WINDOWS_UPGRADE_DIR");
+                                if (StringUtils.isNotEmpty(thingsboardWindowsUpgradeDir)) {
+                                    log.info("Environment variable: {} was found!", THINGSBOARD_WINDOWS_UPGRADE_DIR);
+                                    pathToDir = Paths.get(thingsboardWindowsUpgradeDir);
+                                } else {
+                                    log.info("Failed to lookup environment variable: {}", THINGSBOARD_WINDOWS_UPGRADE_DIR);
+                                    pathToDir = Paths.get(PATH_TO_USERS_PUBLIC_FOLDER);
+                                }
+                                log.info("Directory: {} will be used for creation temporary upgrade files!", pathToDir);
+                                try {
+                                    Path tsKvFile = Files.createTempFile(pathToDir, "ts_kv", ".sql");
+                                    Path tsKvLatestFile = Files.createTempFile(pathToDir, "ts_kv_latest", ".sql");
+                                    pathToTempTsKvFile = tsKvFile.toAbsolutePath();
+                                    pathToTempTsKvLatestFile = tsKvLatestFile.toAbsolutePath();
+                                    executeQuery(conn, "call insert_into_ts_kv('" + pathToTempTsKvFile + "')");
+                                    executeQuery(conn, CALL_CREATE_NEW_TS_KV_LATEST_TABLE);
+                                    executeQuery(conn, "call insert_into_ts_kv_latest('" + pathToTempTsKvLatestFile + "');");
+                                } catch (IOException | SecurityException e) {
+                                    throw new RuntimeException("Failed to create time-series upgrade files due to: " + e);
+                                }
+                            } else {
+                                Path tempDirPath = Files.createTempDirectory("ts_kv");
+                                File tempDirAsFile = tempDirPath.toFile();
+                                boolean writable = tempDirAsFile.setWritable(true, false);
+                                boolean readable = tempDirAsFile.setReadable(true, false);
+                                boolean executable = tempDirAsFile.setExecutable(true, false);
+                                if (writable && readable && executable) {
+                                    pathToTempTsKvFile = tempDirPath.resolve(TS_KV_SQL).toAbsolutePath();
+                                    pathToTempTsKvLatestFile = tempDirPath.resolve(TS_KV_LATEST_SQL).toAbsolutePath();
+                                    executeQuery(conn, "call insert_into_ts_kv('" + pathToTempTsKvFile + "')");
+                                    executeQuery(conn, CALL_CREATE_NEW_TS_KV_LATEST_TABLE);
+                                    executeQuery(conn, "call insert_into_ts_kv_latest('" + pathToTempTsKvLatestFile + "');");
+                                } else {
+                                    throw new RuntimeException("Failed to grant write permissions for the: " + tempDirPath + "folder!");
+                                }
+                            }
+                            if (pathToTempTsKvFile.toFile().exists() && pathToTempTsKvLatestFile.toFile().exists()) {
+                                boolean deleteTsKvFile = pathToTempTsKvFile.toFile().delete();
+                                if (deleteTsKvFile) {
+                                    log.info("Successfully deleted the temp file for ts_kv table upgrade!");
+                                }
+                                boolean deleteTsKvLatestFile = pathToTempTsKvLatestFile.toFile().delete();
+                                if (deleteTsKvLatestFile) {
+                                    log.info("Successfully deleted the temp file for ts_kv_latest table upgrade!");
+                                }
+                            }
 
 
                             executeQuery(conn, DROP_TABLE_TS_KV_OLD);
                             executeQuery(conn, DROP_TABLE_TS_KV_OLD);
                             executeQuery(conn, DROP_TABLE_TS_KV_LATEST_OLD);
                             executeQuery(conn, DROP_TABLE_TS_KV_LATEST_OLD);

@@ -16,6 +16,8 @@
 package org.thingsboard.server.service.install;
 package org.thingsboard.server.service.install;
 
 
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.SystemUtils;
 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.context.annotation.Profile;
 import org.springframework.context.annotation.Profile;
@@ -23,6 +25,9 @@ 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.TimescaleDBTsDao;
 import org.thingsboard.server.dao.util.TimescaleDBTsDao;
 
 
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.Paths;
 import java.sql.Connection;
 import java.sql.Connection;
@@ -47,14 +52,13 @@ public class TimescaleTsDatabaseUpgradeService extends AbstractSqlTsDatabaseUpgr
     private static final String CREATE_NEW_TS_KV_TABLE = "create_new_ts_kv_table()";
     private static final String CREATE_NEW_TS_KV_TABLE = "create_new_ts_kv_table()";
     private static final String CREATE_TS_KV_DICTIONARY_TABLE = "create_ts_kv_dictionary_table()";
     private static final String CREATE_TS_KV_DICTIONARY_TABLE = "create_ts_kv_dictionary_table()";
     private static final String INSERT_INTO_DICTIONARY = "insert_into_dictionary()";
     private static final String INSERT_INTO_DICTIONARY = "insert_into_dictionary()";
-    private static final String INSERT_INTO_TS_KV = "insert_into_ts_kv()";
+    private static final String INSERT_INTO_TS_KV = "insert_into_ts_kv(IN path_to_file varchar)";
     private static final String INSERT_INTO_TS_KV_LATEST = "insert_into_ts_kv_latest()";
     private static final String INSERT_INTO_TS_KV_LATEST = "insert_into_ts_kv_latest()";
 
 
     private static final String CALL_CREATE_TS_KV_LATEST_TABLE = CALL_REGEX + CREATE_TS_KV_LATEST_TABLE;
     private static final String CALL_CREATE_TS_KV_LATEST_TABLE = CALL_REGEX + CREATE_TS_KV_LATEST_TABLE;
     private static final String CALL_CREATE_NEW_TENANT_TS_KV_TABLE = CALL_REGEX + CREATE_NEW_TS_KV_TABLE;
     private static final String CALL_CREATE_NEW_TENANT_TS_KV_TABLE = CALL_REGEX + CREATE_NEW_TS_KV_TABLE;
     private static final String CALL_CREATE_TS_KV_DICTIONARY_TABLE = CALL_REGEX + CREATE_TS_KV_DICTIONARY_TABLE;
     private static final String CALL_CREATE_TS_KV_DICTIONARY_TABLE = CALL_REGEX + CREATE_TS_KV_DICTIONARY_TABLE;
     private static final String CALL_INSERT_INTO_DICTIONARY = CALL_REGEX + INSERT_INTO_DICTIONARY;
     private static final String CALL_INSERT_INTO_DICTIONARY = CALL_REGEX + INSERT_INTO_DICTIONARY;
-    private static final String CALL_INSERT_INTO_TS_KV = CALL_REGEX + INSERT_INTO_TS_KV;
     private static final String CALL_INSERT_INTO_TS_KV_LATEST = CALL_REGEX + INSERT_INTO_TS_KV_LATEST;
     private static final String CALL_INSERT_INTO_TS_KV_LATEST = CALL_REGEX + INSERT_INTO_TS_KV_LATEST;
 
 
     private static final String DROP_OLD_TENANT_TS_KV_TABLE = DROP_TABLE + TENANT_TS_KV_OLD_TABLE;
     private static final String DROP_OLD_TENANT_TS_KV_TABLE = DROP_TABLE + TENANT_TS_KV_OLD_TABLE;
@@ -63,7 +67,7 @@ public class TimescaleTsDatabaseUpgradeService extends AbstractSqlTsDatabaseUpgr
     private static final String DROP_PROCEDURE_CREATE_TENANT_TS_KV_TABLE_COPY = DROP_PROCEDURE_IF_EXISTS + CREATE_NEW_TS_KV_TABLE;
     private static final String DROP_PROCEDURE_CREATE_TENANT_TS_KV_TABLE_COPY = DROP_PROCEDURE_IF_EXISTS + CREATE_NEW_TS_KV_TABLE;
     private static final String DROP_PROCEDURE_CREATE_TS_KV_DICTIONARY_TABLE = DROP_PROCEDURE_IF_EXISTS + CREATE_TS_KV_DICTIONARY_TABLE;
     private static final String DROP_PROCEDURE_CREATE_TS_KV_DICTIONARY_TABLE = DROP_PROCEDURE_IF_EXISTS + CREATE_TS_KV_DICTIONARY_TABLE;
     private static final String DROP_PROCEDURE_INSERT_INTO_DICTIONARY = DROP_PROCEDURE_IF_EXISTS + INSERT_INTO_DICTIONARY;
     private static final String DROP_PROCEDURE_INSERT_INTO_DICTIONARY = DROP_PROCEDURE_IF_EXISTS + INSERT_INTO_DICTIONARY;
-    private static final String DROP_PROCEDURE_INSERT_INTO_TENANT_TS_KV = DROP_PROCEDURE_IF_EXISTS + INSERT_INTO_TS_KV;
+    private static final String DROP_PROCEDURE_INSERT_INTO_TS_KV = DROP_PROCEDURE_IF_EXISTS + INSERT_INTO_TS_KV;
     private static final String DROP_PROCEDURE_INSERT_INTO_TS_KV_LATEST = DROP_PROCEDURE_IF_EXISTS + INSERT_INTO_TS_KV_LATEST;
     private static final String DROP_PROCEDURE_INSERT_INTO_TS_KV_LATEST = DROP_PROCEDURE_IF_EXISTS + INSERT_INTO_TS_KV_LATEST;
 
 
     @Autowired
     @Autowired
@@ -91,7 +95,49 @@ public class TimescaleTsDatabaseUpgradeService extends AbstractSqlTsDatabaseUpgr
 
 
                             executeQuery(conn, CALL_CREATE_TS_KV_DICTIONARY_TABLE);
                             executeQuery(conn, CALL_CREATE_TS_KV_DICTIONARY_TABLE);
                             executeQuery(conn, CALL_INSERT_INTO_DICTIONARY);
                             executeQuery(conn, CALL_INSERT_INTO_DICTIONARY);
-                            executeQuery(conn, CALL_INSERT_INTO_TS_KV);
+
+                            Path pathToTempTsKvFile;
+                            if (SystemUtils.IS_OS_WINDOWS) {
+                                Path pathToDir;
+                                log.info("Lookup for environment variable: {} ...", THINGSBOARD_WINDOWS_UPGRADE_DIR);
+                                String thingsboardWindowsUpgradeDir = System.getenv(THINGSBOARD_WINDOWS_UPGRADE_DIR);
+                                if (StringUtils.isNotEmpty(thingsboardWindowsUpgradeDir)) {
+                                    log.info("Environment variable: {} was found!", THINGSBOARD_WINDOWS_UPGRADE_DIR);
+                                    pathToDir = Paths.get(thingsboardWindowsUpgradeDir);
+                                } else {
+                                    log.info("Failed to lookup environment variable: {}", THINGSBOARD_WINDOWS_UPGRADE_DIR);
+                                    pathToDir = Paths.get(PATH_TO_USERS_PUBLIC_FOLDER);
+                                }
+                                log.info("Directory: {} will be used for creation temporary upgrade file!", pathToDir);
+                                try {
+                                    Path tsKvFile = Files.createTempFile(pathToDir, "ts_kv", ".sql");
+                                    pathToTempTsKvFile = tsKvFile.toAbsolutePath();
+                                    executeQuery(conn, "call insert_into_ts_kv('" + pathToTempTsKvFile + "')");
+                                    pathToTempTsKvFile.toFile().deleteOnExit();
+                                } catch (IOException | SecurityException e) {
+                                    throw new RuntimeException("Failed to create time-series upgrade files due to: " + e);
+                                }
+                            } else {
+                                Path tempDirPath = Files.createTempDirectory("ts_kv");
+                                File tempDirAsFile = tempDirPath.toFile();
+                                boolean writable = tempDirAsFile.setWritable(true, false);
+                                boolean readable = tempDirAsFile.setReadable(true, false);
+                                boolean executable = tempDirAsFile.setExecutable(true, false);
+                                if (writable && readable && executable) {
+                                    pathToTempTsKvFile = tempDirPath.resolve(TS_KV_SQL).toAbsolutePath();
+                                    executeQuery(conn, "call insert_into_ts_kv('" + pathToTempTsKvFile + "')");
+                                } else {
+                                    throw new RuntimeException("Failed to grant write permissions for the: " + tempDirPath + "folder!");
+                                }
+                            }
+
+                            if (pathToTempTsKvFile.toFile().exists()) {
+                                boolean deleteTsKvFile = pathToTempTsKvFile.toFile().delete();
+                                if (deleteTsKvFile) {
+                                    log.info("Successfully deleted the temp file for ts_kv table upgrade!");
+                                }
+                            }
+
                             executeQuery(conn, CALL_INSERT_INTO_TS_KV_LATEST);
                             executeQuery(conn, CALL_INSERT_INTO_TS_KV_LATEST);
 
 
                             executeQuery(conn, DROP_OLD_TENANT_TS_KV_TABLE);
                             executeQuery(conn, DROP_OLD_TENANT_TS_KV_TABLE);
@@ -100,7 +146,7 @@ public class TimescaleTsDatabaseUpgradeService extends AbstractSqlTsDatabaseUpgr
                             executeQuery(conn, DROP_PROCEDURE_CREATE_TENANT_TS_KV_TABLE_COPY);
                             executeQuery(conn, DROP_PROCEDURE_CREATE_TENANT_TS_KV_TABLE_COPY);
                             executeQuery(conn, DROP_PROCEDURE_CREATE_TS_KV_DICTIONARY_TABLE);
                             executeQuery(conn, DROP_PROCEDURE_CREATE_TS_KV_DICTIONARY_TABLE);
                             executeQuery(conn, DROP_PROCEDURE_INSERT_INTO_DICTIONARY);
                             executeQuery(conn, DROP_PROCEDURE_INSERT_INTO_DICTIONARY);
-                            executeQuery(conn, DROP_PROCEDURE_INSERT_INTO_TENANT_TS_KV);
+                            executeQuery(conn, DROP_PROCEDURE_INSERT_INTO_TS_KV);
                             executeQuery(conn, DROP_PROCEDURE_INSERT_INTO_TS_KV_LATEST);
                             executeQuery(conn, DROP_PROCEDURE_INSERT_INTO_TS_KV_LATEST);
 
 
                             executeQuery(conn, "ALTER TABLE ts_kv ADD COLUMN IF NOT EXISTS json_v json;");
                             executeQuery(conn, "ALTER TABLE ts_kv ADD COLUMN IF NOT EXISTS json_v json;");

@@ -15,25 +15,27 @@
  */
  */
 package org.thingsboard.server.service.install.cql;
 package org.thingsboard.server.service.install.cql;
 
 
-import com.datastax.driver.core.BoundStatement;
-import com.datastax.driver.core.DataType;
-import com.datastax.driver.core.KeyspaceMetadata;
-import com.datastax.driver.core.PreparedStatement;
-import com.datastax.driver.core.ResultSet;
-import com.datastax.driver.core.Row;
-import com.datastax.driver.core.Session;
-import com.datastax.driver.core.SimpleStatement;
-import com.datastax.driver.core.Statement;
-import com.datastax.driver.core.TableMetadata;
+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.ResultSet;
+import com.datastax.oss.driver.api.core.cql.Row;
+import com.datastax.oss.driver.api.core.cql.SimpleStatement;
+import com.datastax.oss.driver.api.core.cql.Statement;
+import com.datastax.oss.driver.api.core.metadata.schema.KeyspaceMetadata;
+import com.datastax.oss.driver.api.core.metadata.schema.TableMetadata;
+import com.datastax.oss.driver.api.core.type.DataType;
+import com.datastax.oss.protocol.internal.ProtocolConstants;
 import org.apache.commons.csv.CSVFormat;
 import org.apache.commons.csv.CSVFormat;
 import org.apache.commons.csv.CSVParser;
 import org.apache.commons.csv.CSVParser;
 import org.apache.commons.csv.CSVPrinter;
 import org.apache.commons.csv.CSVPrinter;
 import org.apache.commons.csv.CSVRecord;
 import org.apache.commons.csv.CSVRecord;
+import org.thingsboard.server.dao.cassandra.guava.GuavaSession;
 
 
 import java.io.IOException;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Path;
 import java.nio.file.StandardCopyOption;
 import java.nio.file.StandardCopyOption;
+import java.time.Instant;
 import java.util.ArrayList;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.Date;
 import java.util.Iterator;
 import java.util.Iterator;
@@ -44,12 +46,12 @@ import static org.thingsboard.server.service.install.DatabaseHelper.CSV_DUMP_FOR
 
 
 public class CassandraDbHelper {
 public class CassandraDbHelper {
 
 
-    public static Path dumpCfIfExists(KeyspaceMetadata ks, Session session, String cfName,
+    public static Path dumpCfIfExists(KeyspaceMetadata ks, GuavaSession session, String cfName,
                                       String[] columns, String[] defaultValues, String dumpPrefix) throws Exception {
                                       String[] columns, String[] defaultValues, String dumpPrefix) throws Exception {
         return dumpCfIfExists(ks, session, cfName, columns, defaultValues, dumpPrefix, false);
         return dumpCfIfExists(ks, session, cfName, columns, defaultValues, dumpPrefix, false);
     }
     }
 
 
-    public static Path dumpCfIfExists(KeyspaceMetadata ks, Session session, String cfName,
+    public static Path dumpCfIfExists(KeyspaceMetadata ks, GuavaSession session, String cfName,
                                       String[] columns, String[] defaultValues, String dumpPrefix, boolean printHeader) throws Exception {
                                       String[] columns, String[] defaultValues, String dumpPrefix, boolean printHeader) throws Exception {
         if (ks.getTable(cfName) != null) {
         if (ks.getTable(cfName) != null) {
             Path dumpFile = Files.createTempFile(dumpPrefix, null);
             Path dumpFile = Files.createTempFile(dumpPrefix, null);
@@ -59,8 +61,8 @@ public class CassandraDbHelper {
                 csvFormat = csvFormat.withHeader(columns);
                 csvFormat = csvFormat.withHeader(columns);
             }
             }
             try (CSVPrinter csvPrinter = new CSVPrinter(Files.newBufferedWriter(dumpFile), csvFormat)) {
             try (CSVPrinter csvPrinter = new CSVPrinter(Files.newBufferedWriter(dumpFile), csvFormat)) {
-                Statement stmt = new SimpleStatement("SELECT * FROM " + cfName);
-                stmt.setFetchSize(1000);
+                Statement stmt = SimpleStatement.newInstance("SELECT * FROM " + cfName);
+                stmt.setPageSize(1000);
                 ResultSet rs = session.execute(stmt);
                 ResultSet rs = session.execute(stmt);
                 Iterator<Row> iter = rs.iterator();
                 Iterator<Row> iter = rs.iterator();
                 while (iter.hasNext()) {
                 while (iter.hasNext()) {
@@ -95,12 +97,12 @@ public class CassandraDbHelper {
         Files.move(tmp, targetDumpFile, StandardCopyOption.REPLACE_EXISTING);
         Files.move(tmp, targetDumpFile, StandardCopyOption.REPLACE_EXISTING);
     }
     }
 
 
-    public static void loadCf(KeyspaceMetadata ks, Session session, String cfName, String[] columns, Path sourceFile) throws Exception {
+    public static void loadCf(KeyspaceMetadata ks, GuavaSession session, String cfName, String[] columns, Path sourceFile) throws Exception {
         loadCf(ks, session, cfName, columns, sourceFile, false);
         loadCf(ks, session, cfName, columns, sourceFile, false);
     }
     }
 
 
-    public static void loadCf(KeyspaceMetadata ks, Session session, String cfName, String[] columns, Path sourceFile, boolean parseHeader) throws Exception {
-        TableMetadata tableMetadata = ks.getTable(cfName);
+    public static void loadCf(KeyspaceMetadata ks, GuavaSession session, String cfName, String[] columns, Path sourceFile, boolean parseHeader) throws Exception {
+        TableMetadata tableMetadata = ks.getTable(cfName).get();
         PreparedStatement prepared = session.prepare(createInsertStatement(cfName, columns));
         PreparedStatement prepared = session.prepare(createInsertStatement(cfName, columns));
         CSVFormat csvFormat = CSV_DUMP_FORMAT;
         CSVFormat csvFormat = CSV_DUMP_FORMAT;
         if (parseHeader) {
         if (parseHeader) {
@@ -110,11 +112,11 @@ public class CassandraDbHelper {
         }
         }
         try (CSVParser csvParser = new CSVParser(Files.newBufferedReader(sourceFile), csvFormat)) {
         try (CSVParser csvParser = new CSVParser(Files.newBufferedReader(sourceFile), csvFormat)) {
             csvParser.forEach(record -> {
             csvParser.forEach(record -> {
-                BoundStatement boundStatement = prepared.bind();
+                BoundStatementBuilder boundStatementBuilder = new BoundStatementBuilder(prepared.bind());
                 for (String column : columns) {
                 for (String column : columns) {
-                    setColumnValue(tableMetadata, column, record, boundStatement);
+                    setColumnValue(tableMetadata, column, record, boundStatementBuilder);
                 }
                 }
-                session.execute(boundStatement);
+                session.execute(boundStatementBuilder.build());
             });
             });
         }
         }
     }
     }
@@ -136,27 +138,27 @@ public class CassandraDbHelper {
     }
     }
 
 
     private static String getColumnValue(String column, String defaultValue, Row row) {
     private static String getColumnValue(String column, String defaultValue, Row row) {
-        int index = row.getColumnDefinitions().getIndexOf(column);
+        int index = row.getColumnDefinitions().firstIndexOf(column);
         if (index > -1) {
         if (index > -1) {
             String str;
             String str;
-            DataType type = row.getColumnDefinitions().getType(index);
+            DataType type = row.getColumnDefinitions().get(index).getType();
             try {
             try {
                 if (row.isNull(index)) {
                 if (row.isNull(index)) {
                     return null;
                     return null;
-                } else if (type == DataType.cdouble()) {
+                } else if (type.getProtocolCode() == ProtocolConstants.DataType.DOUBLE) {
                     str = new Double(row.getDouble(index)).toString();
                     str = new Double(row.getDouble(index)).toString();
-                } else if (type == DataType.cint()) {
+                } else if (type.getProtocolCode() == ProtocolConstants.DataType.INT) {
                     str = new Integer(row.getInt(index)).toString();
                     str = new Integer(row.getInt(index)).toString();
-                } else if (type == DataType.bigint()) {
+                } else if (type.getProtocolCode() == ProtocolConstants.DataType.BIGINT) {
                     str = new Long(row.getLong(index)).toString();
                     str = new Long(row.getLong(index)).toString();
-                } else if (type == DataType.uuid()) {
-                    str = row.getUUID(index).toString();
-                } else if (type == DataType.timeuuid()) {
-                    str = row.getUUID(index).toString();
-                } else if (type == DataType.cfloat()) {
+                } else if (type.getProtocolCode() == ProtocolConstants.DataType.UUID) {
+                    str = row.getUuid(index).toString();
+                } else if (type.getProtocolCode() == ProtocolConstants.DataType.TIMEUUID) {
+                    str = row.getUuid(index).toString();
+                } else if (type.getProtocolCode() == ProtocolConstants.DataType.FLOAT) {
                     str = new Float(row.getFloat(index)).toString();
                     str = new Float(row.getFloat(index)).toString();
-                } else if (type == DataType.timestamp()) {
-                    str = ""+row.getTimestamp(index).getTime();
+                } else if (type.getProtocolCode() == ProtocolConstants.DataType.TIMESTAMP) {
+                    str = ""+row.getInstant(index).toEpochMilli();
                 } else {
                 } else {
                     str = row.getString(index);
                     str = row.getString(index);
                 }
                 }
@@ -186,27 +188,27 @@ public class CassandraDbHelper {
     }
     }
 
 
     private static void setColumnValue(TableMetadata tableMetadata, String column,
     private static void setColumnValue(TableMetadata tableMetadata, String column,
-                                       CSVRecord record, BoundStatement boundStatement) {
+                                       CSVRecord record, BoundStatementBuilder boundStatementBuilder) {
         String value = record.get(column);
         String value = record.get(column);
-        DataType type = tableMetadata.getColumn(column).getType();
+        DataType type = tableMetadata.getColumn(column).get().getType();
         if (value == null) {
         if (value == null) {
-            boundStatement.setToNull(column);
-        } else if (type == DataType.cdouble()) {
-            boundStatement.setDouble(column, Double.valueOf(value));
-        } else if (type == DataType.cint()) {
-            boundStatement.setInt(column, Integer.valueOf(value));
-        } else if (type == DataType.bigint()) {
-            boundStatement.setLong(column, Long.valueOf(value));
-        } else if (type == DataType.uuid()) {
-            boundStatement.setUUID(column, UUID.fromString(value));
-        } else if (type == DataType.timeuuid()) {
-            boundStatement.setUUID(column, UUID.fromString(value));
-        } else if (type == DataType.cfloat()) {
-            boundStatement.setFloat(column, Float.valueOf(value));
-        } else if (type == DataType.timestamp()) {
-            boundStatement.setTimestamp(column, new Date(Long.valueOf(value)));
+            boundStatementBuilder.setToNull(column);
+        } else if (type.getProtocolCode() == ProtocolConstants.DataType.DOUBLE) {
+            boundStatementBuilder.setDouble(column, Double.valueOf(value));
+        } else if (type.getProtocolCode() == ProtocolConstants.DataType.INT) {
+            boundStatementBuilder.setInt(column, Integer.valueOf(value));
+        } else if (type.getProtocolCode() == ProtocolConstants.DataType.BIGINT) {
+            boundStatementBuilder.setLong(column, Long.valueOf(value));
+        } else if (type.getProtocolCode() == ProtocolConstants.DataType.UUID) {
+            boundStatementBuilder.setUuid(column, UUID.fromString(value));
+        } else if (type.getProtocolCode() == ProtocolConstants.DataType.TIMEUUID) {
+            boundStatementBuilder.setUuid(column, UUID.fromString(value));
+        } else if (type.getProtocolCode() == ProtocolConstants.DataType.FLOAT) {
+            boundStatementBuilder.setFloat(column, Float.valueOf(value));
+        } else if (type.getProtocolCode() == ProtocolConstants.DataType.TIMESTAMP) {
+            boundStatementBuilder.setInstant(column, Instant.ofEpochMilli(Long.valueOf(value)));
         } else {
         } else {
-            boundStatement.setString(column, value);
+            boundStatementBuilder.setString(column, value);
         }
         }
     }
     }
 
 

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.service.install.migrate;
 package org.thingsboard.server.service.install.migrate;
 
 
-import com.datastax.driver.core.Row;
+import com.datastax.oss.driver.api.core.cql.Row;
 import lombok.Data;
 import lombok.Data;
 import org.thingsboard.server.common.data.UUIDConverter;
 import org.thingsboard.server.common.data.UUIDConverter;
 
 
@@ -105,7 +105,7 @@ public class CassandraToSqlColumn {
         } else {
         } else {
             switch (this.type) {
             switch (this.type) {
                 case ID:
                 case ID:
-                    return UUIDConverter.fromTimeUUID(row.getUUID(index));
+                    return UUIDConverter.fromTimeUUID(row.getUuid(index));
                 case DOUBLE:
                 case DOUBLE:
                     return Double.toString(row.getDouble(index));
                     return Double.toString(row.getDouble(index));
                 case INTEGER:
                 case INTEGER:
@@ -115,7 +115,7 @@ public class CassandraToSqlColumn {
                 case BIGINT:
                 case BIGINT:
                     return Long.toString(row.getLong(index));
                     return Long.toString(row.getLong(index));
                 case BOOLEAN:
                 case BOOLEAN:
-                    return Boolean.toString(row.getBool(index));
+                    return Boolean.toString(row.getBoolean(index));
                 case STRING:
                 case STRING:
                 case JSON:
                 case JSON:
                 case ENUM_TO_INT:
                 case ENUM_TO_INT:

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.service.install.migrate;
 package org.thingsboard.server.service.install.migrate;
 
 
-import com.datastax.driver.core.Row;
+import com.datastax.oss.driver.api.core.cql.Row;
 
 
 import java.util.UUID;
 import java.util.UUID;
 
 
@@ -29,7 +29,7 @@ public class CassandraToSqlEventTsColumn extends CassandraToSqlColumn {
 
 
     @Override
     @Override
     public String getColumnValue(Row row) {
     public String getColumnValue(Row row) {
-        UUID id = row.getUUID(getIndex());
+        UUID id = row.getUuid(getIndex());
         long ts = getTs(id);
         long ts = getTs(id);
         return ts + "";
         return ts + "";
     }
     }
@@ -37,4 +37,4 @@ public class CassandraToSqlEventTsColumn extends CassandraToSqlColumn {
     private long getTs(UUID uuid) {
     private long getTs(UUID uuid) {
         return (uuid.timestamp() - EPOCH_DIFF) / 10000;
         return (uuid.timestamp() - EPOCH_DIFF) / 10000;
     }
     }
-}
+}

@@ -15,20 +15,17 @@
  */
  */
 package org.thingsboard.server.service.install.migrate;
 package org.thingsboard.server.service.install.migrate;
 
 
-import com.datastax.driver.core.ResultSet;
-import com.datastax.driver.core.Row;
-import com.datastax.driver.core.Session;
-import com.datastax.driver.core.SimpleStatement;
-import com.datastax.driver.core.Statement;
+import com.datastax.oss.driver.api.core.cql.ResultSet;
+import com.datastax.oss.driver.api.core.cql.Row;
+import com.datastax.oss.driver.api.core.cql.SimpleStatement;
+import com.datastax.oss.driver.api.core.cql.Statement;
 import lombok.Data;
 import lombok.Data;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
-import org.hibernate.exception.ConstraintViolationException;
 import org.hibernate.internal.util.JdbcExceptionHelper;
 import org.hibernate.internal.util.JdbcExceptionHelper;
 import org.postgresql.util.PSQLException;
 import org.postgresql.util.PSQLException;
 import org.thingsboard.server.common.data.UUIDConverter;
 import org.thingsboard.server.common.data.UUIDConverter;
-import org.thingsboard.server.dao.exception.DataValidationException;
+import org.thingsboard.server.dao.cassandra.guava.GuavaSession;
 
 
-import java.sql.BatchUpdateException;
 import java.sql.Connection;
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.DatabaseMetaData;
 import java.sql.PreparedStatement;
 import java.sql.PreparedStatement;
@@ -38,7 +35,6 @@ import java.util.Arrays;
 import java.util.Iterator;
 import java.util.Iterator;
 import java.util.List;
 import java.util.List;
 import java.util.Optional;
 import java.util.Optional;
-import java.util.stream.Collectors;
 
 
 @Data
 @Data
 @Slf4j
 @Slf4j
@@ -78,7 +74,7 @@ public class CassandraToSqlTable {
         }
         }
     }
     }
 
 
-    public void migrateToSql(Session session, Connection conn) throws SQLException {
+    public void migrateToSql(GuavaSession session, Connection conn) throws SQLException {
         log.info("[{}] Migrating data from cassandra '{}' Column Family to '{}' SQL table...", this.sqlTableName, this.cassandraCf, this.sqlTableName);
         log.info("[{}] Migrating data from cassandra '{}' Column Family to '{}' SQL table...", this.sqlTableName, this.cassandraCf, this.sqlTableName);
         DatabaseMetaData metadata = conn.getMetaData();
         DatabaseMetaData metadata = conn.getMetaData();
         java.sql.ResultSet resultSet = metadata.getColumns(null, null, this.sqlTableName, null);
         java.sql.ResultSet resultSet = metadata.getColumns(null, null, this.sqlTableName, null);
@@ -92,7 +88,7 @@ public class CassandraToSqlTable {
         }
         }
         this.sqlInsertStatement = createSqlInsertStatement(conn);
         this.sqlInsertStatement = createSqlInsertStatement(conn);
         Statement cassandraSelectStatement = createCassandraSelectStatement();
         Statement cassandraSelectStatement = createCassandraSelectStatement();
-        cassandraSelectStatement.setFetchSize(100);
+        cassandraSelectStatement.setPageSize(100);
         ResultSet rs = session.execute(cassandraSelectStatement);
         ResultSet rs = session.execute(cassandraSelectStatement);
         Iterator<Row> iter = rs.iterator();
         Iterator<Row> iter = rs.iterator();
         int rowCounter = 0;
         int rowCounter = 0;
@@ -281,7 +277,7 @@ public class CassandraToSqlTable {
         }
         }
         selectStatementBuilder.deleteCharAt(selectStatementBuilder.length() - 1);
         selectStatementBuilder.deleteCharAt(selectStatementBuilder.length() - 1);
         selectStatementBuilder.append(" FROM ").append(cassandraCf);
         selectStatementBuilder.append(" FROM ").append(cassandraCf);
-        return new SimpleStatement(selectStatementBuilder.toString());
+        return SimpleStatement.newInstance(selectStatementBuilder.toString());
     }
     }
 
 
     private PreparedStatement createSqlInsertStatement(Connection conn) throws SQLException {
     private PreparedStatement createSqlInsertStatement(Connection conn) throws SQLException {

@@ -176,9 +176,9 @@ cassandra:
   # Enable/disable secure connection
   # Enable/disable secure connection
   ssl: "${CASSANDRA_USE_SSL:false}"
   ssl: "${CASSANDRA_USE_SSL:false}"
   # Enable/disable JMX
   # Enable/disable JMX
-  jmx: "${CASSANDRA_USE_JMX:true}"
+  jmx: "${CASSANDRA_USE_JMX:false}"
   # Enable/disable metrics collection.
   # Enable/disable metrics collection.
-  metrics: "${CASSANDRA_DISABLE_METRICS:true}"
+  metrics: "${CASSANDRA_USE_METRICS:false}"
   # NONE SNAPPY LZ4
   # NONE SNAPPY LZ4
   compression: "${CASSANDRA_COMPRESSION:none}"
   compression: "${CASSANDRA_COMPRESSION:none}"
   # Specify cassandra cluster initialization timeout in milliseconds (if no hosts available during startup)
   # Specify cassandra cluster initialization timeout in milliseconds (if no hosts available during startup)
@@ -258,11 +258,11 @@ sql:
     ttl:
     ttl:
       ts:
       ts:
         enabled: "${SQL_TTL_TS_ENABLED:true}"
         enabled: "${SQL_TTL_TS_ENABLED:true}"
-        execution_interval_ms: "${SQL_TTL_TS_EXECUTION_INTERVAL:86400000}" # Number of miliseconds. The current value corresponds to one day
+        execution_interval_ms: "${SQL_TTL_TS_EXECUTION_INTERVAL:86400000}" # Number of milliseconds. The current value corresponds to one day
         ts_key_value_ttl: "${SQL_TTL_TS_TS_KEY_VALUE_TTL:0}" # Number of seconds
         ts_key_value_ttl: "${SQL_TTL_TS_TS_KEY_VALUE_TTL:0}" # Number of seconds
       events:
       events:
         enabled: "${SQL_TTL_EVENTS_ENABLED:true}"
         enabled: "${SQL_TTL_EVENTS_ENABLED:true}"
-        execution_interval_ms: "${SQL_TTL_EVENTS_EXECUTION_INTERVAL:86400000}" # Number of miliseconds. The current value corresponds to one day
+        execution_interval_ms: "${SQL_TTL_EVENTS_EXECUTION_INTERVAL:86400000}" # Number of milliseconds. The current value corresponds to one day
         events_ttl: "${SQL_TTL_EVENTS_EVENTS_TTL:0}" # Number of seconds
         events_ttl: "${SQL_TTL_EVENTS_EVENTS_TTL:0}" # Number of seconds
         debug_events_ttl: "${SQL_TTL_EVENTS_DEBUG_EVENTS_TTL:604800}" # Number of seconds. The current value corresponds to one week
         debug_events_ttl: "${SQL_TTL_EVENTS_DEBUG_EVENTS_TTL:604800}" # Number of seconds. The current value corresponds to one week
 
 
@@ -583,6 +583,9 @@ queue:
     linger.ms: "${TB_KAFKA_LINGER_MS:1}"
     linger.ms: "${TB_KAFKA_LINGER_MS:1}"
     buffer.memory: "${TB_BUFFER_MEMORY:33554432}"
     buffer.memory: "${TB_BUFFER_MEMORY:33554432}"
     replication_factor: "${TB_QUEUE_KAFKA_REPLICATION_FACTOR:1}"
     replication_factor: "${TB_QUEUE_KAFKA_REPLICATION_FACTOR:1}"
+    max_poll_records: "${TB_QUEUE_KAFKA_MAX_POLL_RECORDS:8192}"
+    max_partition_fetch_bytes: "${TB_QUEUE_KAFKA_MAX_PARTITION_FETCH_BYTES:16777216}"
+    fetch_max_bytes: "${TB_QUEUE_KAFKA_FETCH_MAX_BYTES:134217728}"
     topic-properties:
     topic-properties:
       rule-engine: "${TB_QUEUE_KAFKA_RE_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000}"
       rule-engine: "${TB_QUEUE_KAFKA_RE_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000}"
       core: "${TB_QUEUE_KAFKA_CORE_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000}"
       core: "${TB_QUEUE_KAFKA_CORE_TOPIC_PROPERTIES:retention.ms:604800000;segment.bytes:26214400;retention.bytes:1048576000}"

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.controller;
 package org.thingsboard.server.controller;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.core.type.TypeReference;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.junit.After;
 import org.junit.After;
@@ -206,7 +206,7 @@ public abstract class BaseAssetControllerTest extends AbstractControllerTest {
         asset.setType("default");
         asset.setType("default");
         Asset savedAsset = doPost("/api/asset", asset, Asset.class);
         Asset savedAsset = doPost("/api/asset", asset, Asset.class);
 
 
-        doPost("/api/customer/" + UUIDs.timeBased().toString()
+        doPost("/api/customer/" + Uuids.timeBased().toString()
                 + "/asset/" + savedAsset.getId().getId().toString())
                 + "/asset/" + savedAsset.getId().getId().toString())
                 .andExpect(status().isNotFound());
                 .andExpect(status().isNotFound());
     }
     }

@@ -24,7 +24,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Collections;
 import java.util.List;
 import java.util.List;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.thingsboard.server.common.data.*;
 import org.thingsboard.server.common.data.*;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
@@ -158,7 +158,7 @@ public abstract class BaseDashboardControllerTest extends AbstractControllerTest
         dashboard.setTitle("My dashboard");
         dashboard.setTitle("My dashboard");
         Dashboard savedDashboard = doPost("/api/dashboard", dashboard, Dashboard.class);
         Dashboard savedDashboard = doPost("/api/dashboard", dashboard, Dashboard.class);
         
         
-        doPost("/api/customer/" + UUIDs.timeBased().toString()
+        doPost("/api/customer/" + Uuids.timeBased().toString()
                 + "/dashboard/" + savedDashboard.getId().getId().toString())
                 + "/dashboard/" + savedDashboard.getId().getId().toString())
         .andExpect(status().isNotFound());
         .andExpect(status().isNotFound());
     }
     }

@@ -23,7 +23,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Collections;
 import java.util.List;
 import java.util.List;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.thingsboard.server.common.data.*;
 import org.thingsboard.server.common.data.*;
 import org.thingsboard.server.common.data.id.CustomerId;
 import org.thingsboard.server.common.data.id.CustomerId;
@@ -215,7 +215,7 @@ public abstract class BaseDeviceControllerTest extends AbstractControllerTest {
         device.setType("default");
         device.setType("default");
         Device savedDevice = doPost("/api/device", device, Device.class);
         Device savedDevice = doPost("/api/device", device, Device.class);
         
         
-        doPost("/api/customer/" + UUIDs.timeBased().toString()
+        doPost("/api/customer/" + Uuids.timeBased().toString()
                 + "/device/" + savedDevice.getId().getId().toString())
                 + "/device/" + savedDevice.getId().getId().toString())
         .andExpect(status().isNotFound());
         .andExpect(status().isNotFound());
     }
     }
@@ -333,7 +333,7 @@ public abstract class BaseDeviceControllerTest extends AbstractControllerTest {
         Device savedDevice = doPost("/api/device", device, Device.class);
         Device savedDevice = doPost("/api/device", device, Device.class);
         DeviceCredentials deviceCredentials = 
         DeviceCredentials deviceCredentials = 
                 doGet("/api/device/" + savedDevice.getId().getId().toString() + "/credentials", DeviceCredentials.class);
                 doGet("/api/device/" + savedDevice.getId().getId().toString() + "/credentials", DeviceCredentials.class);
-        DeviceCredentials newDeviceCredentials = new DeviceCredentials(new DeviceCredentialsId(UUIDs.timeBased()));
+        DeviceCredentials newDeviceCredentials = new DeviceCredentials(new DeviceCredentialsId(Uuids.timeBased()));
         newDeviceCredentials.setCreatedTime(deviceCredentials.getCreatedTime());
         newDeviceCredentials.setCreatedTime(deviceCredentials.getCreatedTime());
         newDeviceCredentials.setDeviceId(deviceCredentials.getDeviceId());
         newDeviceCredentials.setDeviceId(deviceCredentials.getDeviceId());
         newDeviceCredentials.setCredentialsType(deviceCredentials.getCredentialsType());
         newDeviceCredentials.setCredentialsType(deviceCredentials.getCredentialsType());
@@ -351,7 +351,7 @@ public abstract class BaseDeviceControllerTest extends AbstractControllerTest {
         Device savedDevice = doPost("/api/device", device, Device.class);
         Device savedDevice = doPost("/api/device", device, Device.class);
         DeviceCredentials deviceCredentials = 
         DeviceCredentials deviceCredentials = 
                 doGet("/api/device/" + savedDevice.getId().getId().toString() + "/credentials", DeviceCredentials.class);
                 doGet("/api/device/" + savedDevice.getId().getId().toString() + "/credentials", DeviceCredentials.class);
-        deviceCredentials.setDeviceId(new DeviceId(UUIDs.timeBased()));
+        deviceCredentials.setDeviceId(new DeviceId(Uuids.timeBased()));
         doPost("/api/device/credentials", deviceCredentials)
         doPost("/api/device/credentials", deviceCredentials)
         .andExpect(status().isNotFound());
         .andExpect(status().isNotFound());
     }
     }

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.controller;
 package org.thingsboard.server.controller;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.core.type.TypeReference;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.commons.lang3.RandomStringUtils;
@@ -176,7 +176,7 @@ public abstract class BaseEntityViewControllerTest extends AbstractControllerTes
     @Test
     @Test
     public void testAssignEntityViewToNonExistentCustomer() throws Exception {
     public void testAssignEntityViewToNonExistentCustomer() throws Exception {
         EntityView savedView = getNewSavedEntityView("Test entity view");
         EntityView savedView = getNewSavedEntityView("Test entity view");
-        doPost("/api/customer/" + UUIDs.timeBased().toString() + "/device/" + savedView.getId().getId().toString())
+        doPost("/api/customer/" + Uuids.timeBased().toString() + "/device/" + savedView.getId().getId().toString())
                 .andExpect(status().isNotFound());
                 .andExpect(status().isNotFound());
     }
     }
 
 

@@ -34,7 +34,7 @@ public class MqttNoSqlTestSuite {
     @ClassRule
     @ClassRule
     public static CustomSqlUnit sqlUnit = new CustomSqlUnit(
     public static CustomSqlUnit sqlUnit = new CustomSqlUnit(
             Arrays.asList("sql/schema-entities-hsql.sql", "sql/system-data.sql"),
             Arrays.asList("sql/schema-entities-hsql.sql", "sql/system-data.sql"),
-            "sql/drop-all-tables.sql",
+            "sql/hsql/drop-all-tables.sql",
             "nosql-test.properties");
             "nosql-test.properties");
 
 
     @ClassRule
     @ClassRule

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.mqtt.rpc;
 package org.thingsboard.server.mqtt.rpc;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import io.netty.handler.codec.mqtt.MqttQoS;
 import io.netty.handler.codec.mqtt.MqttQoS;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -143,7 +143,7 @@ public abstract class AbstractMqttServerSideRpcIntegrationTest extends AbstractC
     @Test
     @Test
     public void testServerMqttOneWayRpcDeviceDoesNotExist() throws Exception {
     public void testServerMqttOneWayRpcDeviceDoesNotExist() throws Exception {
         String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"25\",\"value\": 1}}";
         String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"25\",\"value\": 1}}";
-        String nonExistentDeviceId = UUIDs.timeBased().toString();
+        String nonExistentDeviceId = Uuids.timeBased().toString();
 
 
         String result = doPostAsync("/api/plugins/rpc/oneway/" + nonExistentDeviceId, setGpioRequest, String.class,
         String result = doPostAsync("/api/plugins/rpc/oneway/" + nonExistentDeviceId, setGpioRequest, String.class,
                 status().isNotFound());
                 status().isNotFound());
@@ -200,7 +200,7 @@ public abstract class AbstractMqttServerSideRpcIntegrationTest extends AbstractC
     @Test
     @Test
     public void testServerMqttTwoWayRpcDeviceDoesNotExist() throws Exception {
     public void testServerMqttTwoWayRpcDeviceDoesNotExist() throws Exception {
         String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"28\",\"value\": 1}}";
         String setGpioRequest = "{\"method\":\"setGpio\",\"params\":{\"pin\": \"28\",\"value\": 1}}";
-        String nonExistentDeviceId = UUIDs.timeBased().toString();
+        String nonExistentDeviceId = Uuids.timeBased().toString();
 
 
         String result = doPostAsync("/api/plugins/rpc/twoway/" + nonExistentDeviceId, setGpioRequest, String.class,
         String result = doPostAsync("/api/plugins/rpc/twoway/" + nonExistentDeviceId, setGpioRequest, String.class,
                 status().isNotFound());
                 status().isNotFound());

@@ -16,7 +16,6 @@
 package org.thingsboard.server.rules.flow;
 package org.thingsboard.server.rules.flow;
 
 
 import akka.actor.ActorRef;
 import akka.actor.ActorRef;
-import com.datastax.driver.core.utils.UUIDs;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.After;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Assert;

@@ -16,7 +16,6 @@
 package org.thingsboard.server.rules.lifecycle;
 package org.thingsboard.server.rules.lifecycle;
 
 
 import akka.actor.ActorRef;
 import akka.actor.ActorRef;
-import com.datastax.driver.core.utils.UUIDs;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.After;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Assert;

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.service.cluster.routing;
 package org.thingsboard.server.service.cluster.routing;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.Assert;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Before;
@@ -101,7 +101,7 @@ public class HashPartitionServiceTest {
     public void testDispersionOnMillionDevices() {
     public void testDispersionOnMillionDevices() {
         List<DeviceId> devices = new ArrayList<>();
         List<DeviceId> devices = new ArrayList<>();
         for (int i = 0; i < ITERATIONS; i++) {
         for (int i = 0; i < ITERATIONS; i++) {
-            devices.add(new DeviceId(UUIDs.timeBased()));
+            devices.add(new DeviceId(Uuids.timeBased()));
         }
         }
         testDevicesDispersion(devices);
         testDevicesDispersion(devices);
     }
     }

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.service.script;
 package org.thingsboard.server.service.script;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.google.common.collect.Sets;
 import com.google.common.collect.Sets;
 import org.junit.After;
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Before;
@@ -41,7 +41,7 @@ public class RuleNodeJsScriptEngineTest {
     private ScriptEngine scriptEngine;
     private ScriptEngine scriptEngine;
     private TestNashornJsInvokeService jsSandboxService;
     private TestNashornJsInvokeService jsSandboxService;
 
 
-    private EntityId ruleNodeId = new RuleNodeId(UUIDs.timeBased());
+    private EntityId ruleNodeId = new RuleNodeId(Uuids.timeBased());
 
 
     @Before
     @Before
     public void beforeTest() throws Exception {
     public void beforeTest() throws Exception {
@@ -247,4 +247,4 @@ public class RuleNodeJsScriptEngineTest {
         }
         }
     }
     }
 
 
-}
+}

@@ -78,18 +78,13 @@
             <scope>provided</scope>
             <scope>provided</scope>
         </dependency>
         </dependency>
         <dependency>
         <dependency>
-            <groupId>com.datastax.cassandra</groupId>
-            <artifactId>cassandra-driver-core</artifactId>
+            <groupId>com.datastax.oss</groupId>
+            <artifactId>java-driver-core</artifactId>
             <scope>provided</scope>
             <scope>provided</scope>
         </dependency>
         </dependency>
         <dependency>
         <dependency>
-            <groupId>com.datastax.cassandra</groupId>
-            <artifactId>cassandra-driver-mapping</artifactId>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.datastax.cassandra</groupId>
-            <artifactId>cassandra-driver-extras</artifactId>
+            <groupId>io.dropwizard.metrics</groupId>
+            <artifactId>metrics-jmx</artifactId>
             <scope>provided</scope>
             <scope>provided</scope>
         </dependency>
         </dependency>
         <dependency>
         <dependency>

@@ -16,117 +16,50 @@
 package org.thingsboard.server.dao.cassandra;
 package org.thingsboard.server.dao.cassandra;
 
 
 
 
-import com.datastax.driver.core.Cluster;
-import com.datastax.driver.core.ConsistencyLevel;
-import com.datastax.driver.core.HostDistance;
-import com.datastax.driver.core.PoolingOptions;
-import com.datastax.driver.core.ProtocolOptions.Compression;
-import com.datastax.driver.core.Session;
-import com.datastax.driver.mapping.DefaultPropertyMapper;
-import com.datastax.driver.mapping.Mapper;
-import com.datastax.driver.mapping.MappingConfiguration;
-import com.datastax.driver.mapping.MappingManager;
-import com.datastax.driver.mapping.PropertyAccessStrategy;
+import com.codahale.metrics.MetricRegistry;
+import com.codahale.metrics.jmx.JmxReporter;
+import com.datastax.oss.driver.api.core.ConsistencyLevel;
 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;
+import org.thingsboard.server.dao.cassandra.guava.GuavaSession;
+import org.thingsboard.server.dao.cassandra.guava.GuavaSessionBuilder;
+import org.thingsboard.server.dao.cassandra.guava.GuavaSessionUtils;
 
 
 import javax.annotation.PreDestroy;
 import javax.annotation.PreDestroy;
-import java.net.InetSocketAddress;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
 
 
 @Slf4j
 @Slf4j
 public abstract class AbstractCassandraCluster {
 public abstract class AbstractCassandraCluster {
 
 
-    private static final String COMMA = ",";
-    private static final String COLON = ":";
-
-    @Value("${cassandra.cluster_name}")
-    private String clusterName;
-    @Value("${cassandra.url}")
-    private String url;
-    @Value("${cassandra.compression}")
-    private String compression;
-    @Value("${cassandra.ssl}")
-    private Boolean ssl;
     @Value("${cassandra.jmx}")
     @Value("${cassandra.jmx}")
     private Boolean jmx;
     private Boolean jmx;
     @Value("${cassandra.metrics}")
     @Value("${cassandra.metrics}")
     private Boolean metrics;
     private Boolean metrics;
-    @Value("${cassandra.credentials}")
-    private Boolean credentials;
-    @Value("${cassandra.username}")
-    private String username;
-    @Value("${cassandra.password}")
-    private String password;
-    @Value("${cassandra.init_timeout_ms}")
-    private long initTimeout;
-    @Value("${cassandra.init_retry_interval_ms}")
-    private long initRetryInterval;
-    @Value("${cassandra.max_requests_per_connection_local:32768}")
-    private int max_requests_local;
-    @Value("${cassandra.max_requests_per_connection_remote:32768}")
-    private int max_requests_remote;
 
 
     @Autowired
     @Autowired
-    private CassandraSocketOptions socketOpts;
-
-    @Autowired
-    private CassandraQueryOptions queryOpts;
+    private CassandraDriverOptions driverOptions;
 
 
     @Autowired
     @Autowired
     private Environment environment;
     private Environment environment;
 
 
-    private Cluster cluster;
-    private Cluster.Builder clusterBuilder;
+    private GuavaSessionBuilder sessionBuilder;
 
 
-    private Session session;
+    private GuavaSession session;
 
 
-    private MappingManager mappingManager;
-
-    public <T> Mapper<T> getMapper(Class<T> clazz) {
-        return mappingManager.mapper(clazz);
-    }
+    private JmxReporter reporter;
 
 
     private String keyspaceName;
     private String keyspaceName;
 
 
     protected void init(String keyspaceName) {
     protected void init(String keyspaceName) {
         this.keyspaceName = keyspaceName;
         this.keyspaceName = keyspaceName;
-        this.clusterBuilder = Cluster.builder()
-                .addContactPointsWithPorts(getContactPoints(url))
-                .withClusterName(clusterName)
-                .withSocketOptions(socketOpts.getOpts())
-                .withPoolingOptions(new PoolingOptions()
-                        .setMaxRequestsPerConnection(HostDistance.LOCAL, max_requests_local)
-                        .setMaxRequestsPerConnection(HostDistance.REMOTE, max_requests_remote));
-        this.clusterBuilder.withQueryOptions(queryOpts.getOpts());
-        this.clusterBuilder.withCompression(StringUtils.isEmpty(compression) ? Compression.NONE : Compression.valueOf(compression.toUpperCase()));
-        if (ssl) {
-            this.clusterBuilder.withSSL();
-        }
-        if (!jmx) {
-            this.clusterBuilder.withoutJMXReporting();
-        }
-        if (!metrics) {
-            this.clusterBuilder.withoutMetrics();
-        }
-        if (credentials) {
-            this.clusterBuilder.withCredentials(username, password);
-        }
+        this.sessionBuilder = GuavaSessionUtils.builder().withConfigLoader(this.driverOptions.getLoader());
         if (!isInstall()) {
         if (!isInstall()) {
             initSession();
             initSession();
         }
         }
     }
     }
 
 
-    public Cluster getCluster() {
-        return cluster;
-    }
-
-    public Session getSession() {
+    public GuavaSession getSession() {
         if (!isInstall()) {
         if (!isInstall()) {
             return session;
             return session;
         } else {
         } else {
@@ -146,64 +79,40 @@ public abstract class AbstractCassandraCluster {
     }
     }
 
 
     private void initSession() {
     private void initSession() {
-        long endTime = System.currentTimeMillis() + initTimeout;
-        while (System.currentTimeMillis() < endTime) {
-            try {
-                cluster = clusterBuilder.build();
-                cluster.init();
-                if (this.keyspaceName != null) {
-                    session = cluster.connect(keyspaceName);
-                } else {
-                    session = cluster.connect();
-                }
-//                For Cassandra Driver version 3.5.0
-                DefaultPropertyMapper propertyMapper = new DefaultPropertyMapper();
-                propertyMapper.setPropertyAccessStrategy(PropertyAccessStrategy.FIELDS);
-                MappingConfiguration configuration = MappingConfiguration.builder().withPropertyMapper(propertyMapper).build();
-                mappingManager = new MappingManager(session, configuration);
-//                For Cassandra Driver version 3.0.0
-//                mappingManager = new MappingManager(session);
-                break;
-            } catch (Exception e) {
-                log.warn("Failed to initialize cassandra cluster due to {}. Will retry in {} ms", e.getMessage(), initRetryInterval);
-                try {
-                    Thread.sleep(initRetryInterval);
-                } catch (InterruptedException ie) {
-                    log.warn("Failed to wait until retry", ie);
-                    Thread.currentThread().interrupt();
-                }
-            }
+        if (this.keyspaceName != null) {
+            this.sessionBuilder.withKeyspace(this.keyspaceName);
+        }
+        this.sessionBuilder.withLocalDatacenter("datacenter1");
+        session = sessionBuilder.build();
+        if (this.metrics && this.jmx) {
+            MetricRegistry registry =
+                    session.getMetrics().orElseThrow(
+                            () -> new IllegalStateException("Metrics are disabled"))
+                    .getRegistry();
+            this.reporter =
+                    JmxReporter.forRegistry(registry)
+                            .inDomain("com.datastax.oss.driver")
+                            .build();
+            this.reporter.start();
         }
         }
     }
     }
 
 
     @PreDestroy
     @PreDestroy
     public void close() {
     public void close() {
-        if (cluster != null) {
-            cluster.close();
+        if (reporter != null) {
+            reporter.stop();
         }
         }
-    }
-
-    private List<InetSocketAddress> getContactPoints(String url) {
-        List<InetSocketAddress> result;
-        if (StringUtils.isBlank(url)) {
-            result = Collections.emptyList();
-        } else {
-            result = new ArrayList<>();
-            for (String hostPort : url.split(COMMA)) {
-                String host = hostPort.split(COLON)[0];
-                Integer port = Integer.valueOf(hostPort.split(COLON)[1]);
-                result.add(new InetSocketAddress(host, port));
-            }
+        if (session != null) {
+            session.close();
         }
         }
-        return result;
     }
     }
 
 
     public ConsistencyLevel getDefaultReadConsistencyLevel() {
     public ConsistencyLevel getDefaultReadConsistencyLevel() {
-        return queryOpts.getDefaultReadConsistencyLevel();
+        return driverOptions.getDefaultReadConsistencyLevel();
     }
     }
 
 
     public ConsistencyLevel getDefaultWriteConsistencyLevel() {
     public ConsistencyLevel getDefaultWriteConsistencyLevel() {
-        return queryOpts.getDefaultWriteConsistencyLevel();
+        return driverOptions.getDefaultWriteConsistencyLevel();
     }
     }
 
 
 }
 }

+/**
+ * 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.cassandra;
+
+import com.datastax.oss.driver.api.core.ConsistencyLevel;
+import com.datastax.oss.driver.api.core.DefaultConsistencyLevel;
+import com.datastax.oss.driver.api.core.config.DefaultDriverOption;
+import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
+import com.datastax.oss.driver.api.core.config.ProgrammaticDriverConfigLoaderBuilder;
+import com.datastax.oss.driver.api.core.metrics.DefaultSessionMetric;
+import com.datastax.oss.driver.api.core.metrics.DefaultNodeMetric;
+import lombok.Data;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.stereotype.Component;
+import org.thingsboard.server.dao.util.NoSqlAnyDao;
+
+import javax.annotation.PostConstruct;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+@Component
+@Configuration
+@Data
+@NoSqlAnyDao
+public class CassandraDriverOptions {
+
+    private static final String COMMA = ",";
+
+    @Value("${cassandra.cluster_name}")
+    private String clusterName;
+    @Value("${cassandra.url}")
+    private String url;
+
+    @Value("${cassandra.socket.connect_timeout}")
+    private int connectTimeoutMillis;
+    @Value("${cassandra.socket.read_timeout}")
+    private int readTimeoutMillis;
+    @Value("${cassandra.socket.keep_alive}")
+    private Boolean keepAlive;
+    @Value("${cassandra.socket.reuse_address}")
+    private Boolean reuseAddress;
+    @Value("${cassandra.socket.so_linger}")
+    private Integer soLinger;
+    @Value("${cassandra.socket.tcp_no_delay}")
+    private Boolean tcpNoDelay;
+    @Value("${cassandra.socket.receive_buffer_size}")
+    private Integer receiveBufferSize;
+    @Value("${cassandra.socket.send_buffer_size}")
+    private Integer sendBufferSize;
+
+    @Value("${cassandra.max_requests_per_connection_local:32768}")
+    private int max_requests_local;
+    @Value("${cassandra.max_requests_per_connection_remote:32768}")
+    private int max_requests_remote;
+
+    @Value("${cassandra.query.default_fetch_size}")
+    private Integer defaultFetchSize;
+    @Value("${cassandra.query.read_consistency_level}")
+    private String readConsistencyLevel;
+    @Value("${cassandra.query.write_consistency_level}")
+    private String writeConsistencyLevel;
+
+    @Value("${cassandra.compression}")
+    private String compression;
+    @Value("${cassandra.ssl}")
+    private Boolean ssl;
+    @Value("${cassandra.metrics}")
+    private Boolean metrics;
+
+    @Value("${cassandra.credentials}")
+    private Boolean credentials;
+    @Value("${cassandra.username}")
+    private String username;
+    @Value("${cassandra.password}")
+    private String password;
+
+    @Value("${cassandra.init_timeout_ms}")
+    private long initTimeout;
+    @Value("${cassandra.init_retry_interval_ms}")
+    private long initRetryInterval;
+
+    private DriverConfigLoader loader;
+
+    private ConsistencyLevel defaultReadConsistencyLevel;
+    private ConsistencyLevel defaultWriteConsistencyLevel;
+
+    @PostConstruct
+    public void initLoader() {
+        ProgrammaticDriverConfigLoaderBuilder driverConfigBuilder =
+                DriverConfigLoader.programmaticBuilder();
+
+        driverConfigBuilder
+                .withStringList(DefaultDriverOption.CONTACT_POINTS, getContactPoints(url))
+                .withString(DefaultDriverOption.SESSION_NAME, clusterName);
+
+        this.initSocketOptions(driverConfigBuilder);
+        this.initPoolingOptions(driverConfigBuilder);
+        this.initQueryOptions(driverConfigBuilder);
+
+        driverConfigBuilder.withString(DefaultDriverOption.PROTOCOL_COMPRESSION,
+                StringUtils.isEmpty(this.compression) ? "none" : this.compression.toLowerCase());
+
+        if (this.ssl) {
+            driverConfigBuilder.withString(DefaultDriverOption.SSL_ENGINE_FACTORY_CLASS,
+                    "DefaultSslEngineFactory");
+        }
+
+        if (this.metrics) {
+            driverConfigBuilder.withStringList(DefaultDriverOption.METRICS_SESSION_ENABLED,
+                    Arrays.asList(DefaultSessionMetric.CONNECTED_NODES.getPath(),
+                            DefaultSessionMetric.CQL_REQUESTS.getPath()));
+            driverConfigBuilder.withStringList(DefaultDriverOption.METRICS_NODE_ENABLED,
+                    Arrays.asList(DefaultNodeMetric.OPEN_CONNECTIONS.getPath(),
+                            DefaultNodeMetric.IN_FLIGHT.getPath()));
+        }
+
+        if (this.credentials) {
+            driverConfigBuilder.withString(DefaultDriverOption.AUTH_PROVIDER_CLASS,
+                    "PlainTextAuthProvider");
+            driverConfigBuilder.withString(DefaultDriverOption.AUTH_PROVIDER_USER_NAME,
+                    this.username);
+            driverConfigBuilder.withString(DefaultDriverOption.AUTH_PROVIDER_PASSWORD,
+                    this.password);
+        }
+
+        driverConfigBuilder.withBoolean(DefaultDriverOption.RECONNECT_ON_INIT,
+                    true);
+        driverConfigBuilder.withString(DefaultDriverOption.RECONNECTION_POLICY_CLASS,
+                "ExponentialReconnectionPolicy");
+        driverConfigBuilder.withDuration(DefaultDriverOption.RECONNECTION_BASE_DELAY,
+                Duration.ofMillis(this.initRetryInterval));
+        driverConfigBuilder.withDuration(DefaultDriverOption.RECONNECTION_MAX_DELAY,
+                Duration.ofMillis(this.initTimeout));
+
+        this.loader = driverConfigBuilder.build();
+    }
+
+    protected ConsistencyLevel getDefaultReadConsistencyLevel() {
+        if (defaultReadConsistencyLevel == null) {
+            if (readConsistencyLevel != null) {
+                defaultReadConsistencyLevel = DefaultConsistencyLevel.valueOf(readConsistencyLevel.toUpperCase());
+            } else {
+                defaultReadConsistencyLevel = DefaultConsistencyLevel.ONE;
+            }
+        }
+        return defaultReadConsistencyLevel;
+    }
+
+    protected ConsistencyLevel getDefaultWriteConsistencyLevel() {
+        if (defaultWriteConsistencyLevel == null) {
+            if (writeConsistencyLevel != null) {
+                defaultWriteConsistencyLevel = DefaultConsistencyLevel.valueOf(writeConsistencyLevel.toUpperCase());
+            } else {
+                defaultWriteConsistencyLevel = DefaultConsistencyLevel.ONE;
+            }
+        }
+        return defaultWriteConsistencyLevel;
+    }
+
+    private void initSocketOptions(ProgrammaticDriverConfigLoaderBuilder driverConfigBuilder) {
+        driverConfigBuilder.withDuration(DefaultDriverOption.CONNECTION_CONNECT_TIMEOUT,
+                Duration.ofMillis(this.connectTimeoutMillis));
+        driverConfigBuilder.withDuration(DefaultDriverOption.REQUEST_TIMEOUT,
+                Duration.ofMillis(this.readTimeoutMillis));
+        if (this.keepAlive != null) {
+            driverConfigBuilder.withBoolean(DefaultDriverOption.SOCKET_KEEP_ALIVE,
+                    this.keepAlive);
+        }
+        if (this.reuseAddress != null) {
+            driverConfigBuilder.withBoolean(DefaultDriverOption.SOCKET_REUSE_ADDRESS,
+                    this.reuseAddress);
+        }
+        if (this.soLinger != null) {
+            driverConfigBuilder.withInt(DefaultDriverOption.SOCKET_LINGER_INTERVAL,
+                    this.soLinger);
+        }
+        if (this.tcpNoDelay != null) {
+            driverConfigBuilder.withBoolean(DefaultDriverOption.SOCKET_TCP_NODELAY,
+                    this.tcpNoDelay);
+        }
+        if (this.receiveBufferSize != null) {
+            driverConfigBuilder.withInt(DefaultDriverOption.SOCKET_RECEIVE_BUFFER_SIZE,
+                    this.receiveBufferSize);
+        }
+        if (this.sendBufferSize != null) {
+            driverConfigBuilder.withInt(DefaultDriverOption.SOCKET_SEND_BUFFER_SIZE,
+                    this.sendBufferSize);
+        }
+    }
+
+    private void initPoolingOptions(ProgrammaticDriverConfigLoaderBuilder driverConfigBuilder) {
+        driverConfigBuilder.withInt(DefaultDriverOption.CONNECTION_MAX_REQUESTS,
+                this.max_requests_local);
+    }
+
+    private void initQueryOptions(ProgrammaticDriverConfigLoaderBuilder driverConfigBuilder) {
+        driverConfigBuilder.withInt(DefaultDriverOption.REQUEST_PAGE_SIZE,
+                this.defaultFetchSize);
+    }
+
+    private List<String> getContactPoints(String url) {
+        List<String> result;
+        if (StringUtils.isBlank(url)) {
+            result = Collections.emptyList();
+        } else {
+            result = new ArrayList<>();
+            for (String hostPort : url.split(COMMA)) {
+                result.add(hostPort);
+            }
+        }
+        return result;
+    }
+
+}

-/**
- * 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.cassandra;
-
-import com.datastax.driver.core.ConsistencyLevel;
-import com.datastax.driver.core.QueryOptions;
-import lombok.Data;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.stereotype.Component;
-import org.thingsboard.server.dao.util.NoSqlAnyDao;
-
-import javax.annotation.PostConstruct;
-
-@Component
-@Configuration
-@Data
-@NoSqlAnyDao
-public class CassandraQueryOptions {
-
-    @Value("${cassandra.query.default_fetch_size}")
-    private Integer defaultFetchSize;
-    @Value("${cassandra.query.read_consistency_level}")
-    private String readConsistencyLevel;
-    @Value("${cassandra.query.write_consistency_level}")
-    private String writeConsistencyLevel;
-
-    private QueryOptions opts;
-
-    private ConsistencyLevel defaultReadConsistencyLevel;
-    private ConsistencyLevel defaultWriteConsistencyLevel;
-
-    @PostConstruct
-    public void initOpts(){
-        opts = new QueryOptions();
-        opts.setFetchSize(defaultFetchSize);
-    }
-
-    protected ConsistencyLevel getDefaultReadConsistencyLevel() {
-        if (defaultReadConsistencyLevel == null) {
-            if (readConsistencyLevel != null) {
-                defaultReadConsistencyLevel = ConsistencyLevel.valueOf(readConsistencyLevel.toUpperCase());
-            } else {
-                defaultReadConsistencyLevel = ConsistencyLevel.ONE;
-            }
-        }
-        return defaultReadConsistencyLevel;
-    }
-
-    protected ConsistencyLevel getDefaultWriteConsistencyLevel() {
-        if (defaultWriteConsistencyLevel == null) {
-            if (writeConsistencyLevel != null) {
-                defaultWriteConsistencyLevel = ConsistencyLevel.valueOf(writeConsistencyLevel.toUpperCase());
-            } else {
-                defaultWriteConsistencyLevel = ConsistencyLevel.ONE;
-            }
-        }
-        return defaultWriteConsistencyLevel;
-    }
-}

-/**
- * 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.cassandra;
-
-import com.datastax.driver.core.SocketOptions;
-import lombok.Data;
-import org.springframework.beans.factory.annotation.Value;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.stereotype.Component;
-import org.thingsboard.server.dao.util.NoSqlAnyDao;
-
-import javax.annotation.PostConstruct;
-
-@Component
-@Configuration
-@Data
-@NoSqlAnyDao
-public class CassandraSocketOptions {
-
-    @Value("${cassandra.socket.connect_timeout}")
-    private int connectTimeoutMillis;
-    @Value("${cassandra.socket.read_timeout}")
-    private int readTimeoutMillis;
-    @Value("${cassandra.socket.keep_alive}")
-    private Boolean keepAlive;
-    @Value("${cassandra.socket.reuse_address}")
-    private Boolean reuseAddress;
-    @Value("${cassandra.socket.so_linger}")
-    private Integer soLinger;
-    @Value("${cassandra.socket.tcp_no_delay}")
-    private Boolean tcpNoDelay;
-    @Value("${cassandra.socket.receive_buffer_size}")
-    private Integer receiveBufferSize;
-    @Value("${cassandra.socket.send_buffer_size}")
-    private Integer sendBufferSize;
-
-    private SocketOptions opts;
-
-    @PostConstruct
-    public void initOpts() {
-        opts = new SocketOptions();
-        opts.setConnectTimeoutMillis(connectTimeoutMillis);
-        opts.setReadTimeoutMillis(readTimeoutMillis);
-        if (keepAlive != null) {
-            opts.setKeepAlive(keepAlive);
-        }
-        if (reuseAddress != null) {
-            opts.setReuseAddress(reuseAddress);
-        }
-        if (soLinger != null) {
-            opts.setSoLinger(soLinger);
-        }
-        if (tcpNoDelay != null) {
-            opts.setTcpNoDelay(tcpNoDelay);
-        }
-        if (receiveBufferSize != null) {
-            opts.setReceiveBufferSize(receiveBufferSize);
-        }
-        if (sendBufferSize != null) {
-            opts.setSendBufferSize(sendBufferSize);
-        }
-    }
-}

@@ -13,15 +13,14 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
-package org.thingsboard.server.dao.model.type;
+package org.thingsboard.server.dao.cassandra.guava;
 
 
-import com.datastax.driver.extras.codecs.json.JacksonJsonCodec;
-import com.fasterxml.jackson.databind.JsonNode;
+import com.datastax.oss.driver.api.core.session.Session;
+import com.datastax.oss.driver.internal.core.session.SessionWrapper;
 
 
-public class JsonCodec extends JacksonJsonCodec<JsonNode> {
+public class DefaultGuavaSession extends SessionWrapper implements GuavaSession {
 
 
-    public JsonCodec() {
-        super(JsonNode.class);
+    public DefaultGuavaSession(Session delegate) {
+        super(delegate);
     }
     }
-
 }
 }

+/**
+ * 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.cassandra.guava;
+
+import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
+import com.datastax.oss.driver.api.core.cql.PrepareRequest;
+import com.datastax.oss.driver.api.core.cql.Statement;
+import com.datastax.oss.driver.api.core.metadata.Node;
+import com.datastax.oss.driver.api.core.metadata.NodeStateListener;
+import com.datastax.oss.driver.api.core.metadata.schema.SchemaChangeListener;
+import com.datastax.oss.driver.api.core.session.ProgrammaticArguments;
+import com.datastax.oss.driver.api.core.tracker.RequestTracker;
+import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
+import com.datastax.oss.driver.internal.core.context.DefaultDriverContext;
+import com.datastax.oss.driver.internal.core.cql.CqlPrepareAsyncProcessor;
+import com.datastax.oss.driver.internal.core.cql.CqlPrepareSyncProcessor;
+import com.datastax.oss.driver.internal.core.cql.CqlRequestAsyncProcessor;
+import com.datastax.oss.driver.internal.core.cql.CqlRequestSyncProcessor;
+import com.datastax.oss.driver.internal.core.session.RequestProcessorRegistry;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Predicate;
+
+/**
+ * A Custom {@link DefaultDriverContext} that overrides {@link #getRequestProcessorRegistry()} to
+ * return a {@link RequestProcessorRegistry} that includes processors for returning guava futures.
+ */
+public class GuavaDriverContext extends DefaultDriverContext {
+
+    public GuavaDriverContext(
+            DriverConfigLoader configLoader,
+            List<TypeCodec<?>> typeCodecs,
+            NodeStateListener nodeStateListener,
+            SchemaChangeListener schemaChangeListener,
+            RequestTracker requestTracker,
+            Map<String, String> localDatacenters,
+            Map<String, Predicate<Node>> nodeFilters,
+            ClassLoader classLoader) {
+        super(
+                configLoader,
+                ProgrammaticArguments.builder()
+                        .addTypeCodecs(typeCodecs.toArray(new TypeCodec<?>[0]))
+                        .withNodeStateListener(nodeStateListener)
+                        .withSchemaChangeListener(schemaChangeListener)
+                        .withRequestTracker(requestTracker)
+                        .withLocalDatacenters(localDatacenters)
+                        .withNodeFilters(nodeFilters)
+                        .withClassLoader(classLoader)
+                        .build());
+    }
+
+    @Override
+    public RequestProcessorRegistry buildRequestProcessorRegistry() {
+        // Register the typical request processors, except instead of the normal async processors,
+        // use GuavaRequestAsyncProcessor to return ListenableFutures in async methods.
+
+        CqlRequestAsyncProcessor cqlRequestAsyncProcessor = new CqlRequestAsyncProcessor();
+        CqlPrepareAsyncProcessor cqlPrepareAsyncProcessor = new CqlPrepareAsyncProcessor();
+        CqlRequestSyncProcessor cqlRequestSyncProcessor =
+                new CqlRequestSyncProcessor(cqlRequestAsyncProcessor);
+
+        return new RequestProcessorRegistry(
+                getSessionName(),
+                cqlRequestSyncProcessor,
+                new CqlPrepareSyncProcessor(cqlPrepareAsyncProcessor),
+                new GuavaRequestAsyncProcessor<>(
+                        cqlRequestAsyncProcessor, Statement.class, GuavaSession.ASYNC),
+                new GuavaRequestAsyncProcessor<>(
+                        cqlPrepareAsyncProcessor, PrepareRequest.class, GuavaSession.ASYNC_PREPARED));
+    }
+}

+/**
+ * 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.cassandra.guava;
+
+import com.datastax.oss.driver.api.core.session.Request;
+import com.datastax.oss.driver.api.core.type.reflect.GenericType;
+import com.datastax.oss.driver.internal.core.context.InternalDriverContext;
+import com.datastax.oss.driver.internal.core.session.DefaultSession;
+import com.datastax.oss.driver.internal.core.session.RequestProcessor;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.SettableFuture;
+import java.util.concurrent.CompletionStage;
+
+/**
+ * Wraps a {@link RequestProcessor} that returns {@link CompletionStage}s and converts them to a
+ * {@link ListenableFuture}s.
+ *
+ * @param <T> The type of request
+ * @param <U> The type of responses enclosed in the future response.
+ */
+public class GuavaRequestAsyncProcessor<T extends Request, U>
+        implements RequestProcessor<T, ListenableFuture<U>> {
+
+    private final RequestProcessor<T, CompletionStage<U>> subProcessor;
+
+    private final GenericType resultType;
+
+    private final Class<?> requestClass;
+
+    GuavaRequestAsyncProcessor(
+            RequestProcessor<T, CompletionStage<U>> subProcessor,
+            Class<?> requestClass,
+            GenericType resultType) {
+        this.subProcessor = subProcessor;
+        this.requestClass = requestClass;
+        this.resultType = resultType;
+    }
+
+    @Override
+    public boolean canProcess(Request request, GenericType resultType) {
+        return requestClass.isInstance(request) && resultType.equals(this.resultType);
+    }
+
+    @Override
+    public ListenableFuture<U> process(
+            T request, DefaultSession session, InternalDriverContext context, String sessionLogPrefix) {
+        SettableFuture<U> future = SettableFuture.create();
+        subProcessor
+                .process(request, session, context, sessionLogPrefix)
+                .whenComplete(
+                        (r, ex) -> {
+                            if (ex != null) {
+                                future.setException(ex);
+                            } else {
+                                future.set(r);
+                            }
+                        });
+        return future;
+    }
+
+    @Override
+    public ListenableFuture<U> newFailure(RuntimeException error) {
+        return Futures.immediateFailedFuture(error);
+    }
+}

@@ -13,15 +13,39 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
-package org.thingsboard.server.dao.model.type;
+package org.thingsboard.server.dao.cassandra.guava;
 
 
-import com.datastax.driver.extras.codecs.enums.EnumNameCodec;
-import org.thingsboard.server.common.data.plugin.ComponentLifecycleState;
+import com.datastax.oss.driver.api.core.cql.AsyncResultSet;
+import com.datastax.oss.driver.api.core.cql.PreparedStatement;
+import com.datastax.oss.driver.api.core.cql.SimpleStatement;
+import com.datastax.oss.driver.api.core.cql.Statement;
+import com.datastax.oss.driver.api.core.cql.SyncCqlSession;
+import com.datastax.oss.driver.api.core.session.Session;
+import com.datastax.oss.driver.api.core.type.reflect.GenericType;
+import com.datastax.oss.driver.internal.core.cql.DefaultPrepareRequest;
+import com.google.common.util.concurrent.ListenableFuture;
 
 
-public class ComponentLifecycleStateCodec extends EnumNameCodec<ComponentLifecycleState> {
+public interface GuavaSession extends Session, SyncCqlSession {
 
 
-    public ComponentLifecycleStateCodec() {
-        super(ComponentLifecycleState.class);
+    GenericType<ListenableFuture<AsyncResultSet>> ASYNC =
+            new GenericType<ListenableFuture<AsyncResultSet>>() {};
+
+    GenericType<ListenableFuture<PreparedStatement>> ASYNC_PREPARED =
+            new GenericType<ListenableFuture<PreparedStatement>>() {};
+
+    default ListenableFuture<AsyncResultSet> executeAsync(Statement<?> statement) {
+        return this.execute(statement, ASYNC);
+    }
+
+    default ListenableFuture<AsyncResultSet> executeAsync(String statement) {
+        return this.executeAsync(SimpleStatement.newInstance(statement));
     }
     }
 
 
+    default ListenableFuture<PreparedStatement> prepareAsync(SimpleStatement statement) {
+        return this.execute(new DefaultPrepareRequest(statement), ASYNC_PREPARED);
+    }
+
+    default ListenableFuture<PreparedStatement> prepareAsync(String statement) {
+        return this.prepareAsync(SimpleStatement.newInstance(statement));
+    }
 }
 }

+/**
+ * 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.cassandra.guava;
+
+import com.datastax.oss.driver.api.core.CqlSession;
+import com.datastax.oss.driver.api.core.config.DriverConfigLoader;
+import com.datastax.oss.driver.api.core.context.DriverContext;
+import com.datastax.oss.driver.api.core.metadata.Node;
+import com.datastax.oss.driver.api.core.metadata.NodeStateListener;
+import com.datastax.oss.driver.api.core.metadata.schema.SchemaChangeListener;
+import com.datastax.oss.driver.api.core.session.SessionBuilder;
+import com.datastax.oss.driver.api.core.tracker.RequestTracker;
+import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Predicate;
+
+public class GuavaSessionBuilder extends SessionBuilder<GuavaSessionBuilder, GuavaSession> {
+
+    @Override
+    protected DriverContext buildContext(
+            DriverConfigLoader configLoader,
+            List<TypeCodec<?>> typeCodecs,
+            NodeStateListener nodeStateListener,
+            SchemaChangeListener schemaChangeListener,
+            RequestTracker requestTracker,
+            Map<String, String> localDatacenters,
+            Map<String, Predicate<Node>> nodeFilters,
+            ClassLoader classLoader) {
+        return new GuavaDriverContext(
+                configLoader,
+                typeCodecs,
+                nodeStateListener,
+                schemaChangeListener,
+                requestTracker,
+                localDatacenters,
+                nodeFilters,
+                classLoader);
+    }
+
+    @Override
+    protected GuavaSession wrap(@NonNull CqlSession defaultSession) {
+        return new DefaultGuavaSession(defaultSession);
+    }
+}

@@ -13,15 +13,10 @@
  * See the License for the specific language governing permissions and
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * limitations under the License.
  */
  */
-package org.thingsboard.server.dao.model.type;
+package org.thingsboard.server.dao.cassandra.guava;
 
 
-import com.datastax.driver.extras.codecs.enums.EnumNameCodec;
-import org.thingsboard.server.common.data.EntityType;
-
-public class EntityTypeCodec extends EnumNameCodec<EntityType> {
-
-    public EntityTypeCodec() {
-        super(EntityType.class);
+public class GuavaSessionUtils {
+    public static GuavaSessionBuilder builder() {
+        return new GuavaSessionBuilder();
     }
     }
-
 }
 }

@@ -15,12 +15,17 @@
  */
  */
 package org.thingsboard.server.dao.nosql;
 package org.thingsboard.server.dao.nosql;
 
 
-import com.datastax.driver.core.Session;
-import com.datastax.driver.core.Statement;
+import com.datastax.oss.driver.api.core.cql.Statement;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.MoreExecutors;
 import lombok.Data;
 import lombok.Data;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.dao.cassandra.guava.GuavaSession;
 import org.thingsboard.server.dao.util.AsyncTask;
 import org.thingsboard.server.dao.util.AsyncTask;
 
 
+import java.util.function.Function;
+
 /**
 /**
  * Created by ashvayka on 24.10.18.
  * Created by ashvayka on 24.10.18.
  */
  */
@@ -28,7 +33,14 @@ import org.thingsboard.server.dao.util.AsyncTask;
 public class CassandraStatementTask implements AsyncTask {
 public class CassandraStatementTask implements AsyncTask {
 
 
     private final TenantId tenantId;
     private final TenantId tenantId;
-    private final Session session;
+    private final GuavaSession session;
     private final Statement statement;
     private final Statement statement;
 
 
+    public ListenableFuture<TbResultSet> executeAsync(Function<Statement, TbResultSetFuture> executeAsyncFunction) {
+        return Futures.transform(session.executeAsync(statement),
+                result -> new TbResultSet(statement, result, executeAsyncFunction),
+                MoreExecutors.directExecutor()
+        );
+    }
+
 }
 }

+/**
+ * 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.nosql;
+
+import com.datastax.oss.driver.api.core.cql.AsyncResultSet;
+import com.datastax.oss.driver.api.core.cql.ColumnDefinitions;
+import com.datastax.oss.driver.api.core.cql.ExecutionInfo;
+import com.datastax.oss.driver.api.core.cql.Row;
+import com.datastax.oss.driver.api.core.cql.Statement;
+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 com.google.common.util.concurrent.SettableFuture;
+import edu.umd.cs.findbugs.annotations.NonNull;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.Executor;
+import java.util.function.Function;
+
+public class TbResultSet implements AsyncResultSet {
+
+    private final Statement originalStatement;
+    private final AsyncResultSet delegate;
+    private final Function<Statement, TbResultSetFuture> executeAsyncFunction;
+
+    public TbResultSet(Statement originalStatement, AsyncResultSet delegate,
+                       Function<Statement, TbResultSetFuture> executeAsyncFunction) {
+        this.originalStatement = originalStatement;
+        this.delegate = delegate;
+        this.executeAsyncFunction = executeAsyncFunction;
+    }
+
+    @NonNull
+    @Override
+    public ColumnDefinitions getColumnDefinitions() {
+        return delegate.getColumnDefinitions();
+    }
+
+    @NonNull
+    @Override
+    public ExecutionInfo getExecutionInfo() {
+        return delegate.getExecutionInfo();
+    }
+
+    @Override
+    public int remaining() {
+        return delegate.remaining();
+    }
+
+    @NonNull
+    @Override
+    public Iterable<Row> currentPage() {
+        return delegate.currentPage();
+    }
+
+    @Override
+    public boolean hasMorePages() {
+        return delegate.hasMorePages();
+    }
+
+    @NonNull
+    @Override
+    public CompletionStage<AsyncResultSet> fetchNextPage() throws IllegalStateException {
+        return delegate.fetchNextPage();
+    }
+
+    @Override
+    public boolean wasApplied() {
+        return delegate.wasApplied();
+    }
+
+    public ListenableFuture<List<Row>> allRows(Executor executor) {
+        List<Row> allRows = new ArrayList<>();
+        SettableFuture<List<Row>> resultFuture = SettableFuture.create();
+        this.processRows(originalStatement, delegate, allRows, resultFuture, executor);
+        return resultFuture;
+    }
+
+    private void processRows(Statement statement,
+                             AsyncResultSet resultSet,
+                             List<Row> allRows,
+                             SettableFuture<List<Row>> resultFuture,
+                             Executor executor) {
+        allRows.addAll(loadRows(resultSet));
+        if (resultSet.hasMorePages()) {
+            ByteBuffer nextPagingState = resultSet.getExecutionInfo().getPagingState();
+            Statement<?> nextStatement = statement.setPagingState(nextPagingState);
+            TbResultSetFuture resultSetFuture = executeAsyncFunction.apply(nextStatement);
+            Futures.addCallback(resultSetFuture,
+                    new FutureCallback<TbResultSet>() {
+                        @Override
+                        public void onSuccess(@Nullable TbResultSet result) {
+                            processRows(nextStatement, result,
+                                    allRows, resultFuture, executor);
+                        }
+
+                        @Override
+                        public void onFailure(Throwable t) {
+                            resultFuture.setException(t);
+                        }
+                    }, executor != null ? executor : MoreExecutors.directExecutor()
+            );
+        } else {
+            resultFuture.set(allRows);
+        }
+    }
+
+    List<Row> loadRows(AsyncResultSet resultSet) {
+        return Lists.newArrayList(resultSet.currentPage());
+    }
+
+}

@@ -15,8 +15,8 @@
  */
  */
 package org.thingsboard.server.dao.nosql;
 package org.thingsboard.server.dao.nosql;
 
 
-import com.datastax.driver.core.ResultSet;
-import com.datastax.driver.core.ResultSetFuture;
+import com.datastax.oss.driver.api.core.cql.AsyncResultSet;
+import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.SettableFuture;
 import com.google.common.util.concurrent.SettableFuture;
 
 
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutionException;
@@ -27,21 +27,19 @@ import java.util.concurrent.TimeoutException;
 /**
 /**
  * Created by ashvayka on 24.10.18.
  * Created by ashvayka on 24.10.18.
  */
  */
-public class TbResultSetFuture implements ResultSetFuture {
+public class TbResultSetFuture implements ListenableFuture<TbResultSet> {
 
 
-    private final SettableFuture<ResultSet> mainFuture;
+    private final SettableFuture<TbResultSet> mainFuture;
 
 
-    public TbResultSetFuture(SettableFuture<ResultSet> mainFuture) {
+    public TbResultSetFuture(SettableFuture<TbResultSet> mainFuture) {
         this.mainFuture = mainFuture;
         this.mainFuture = mainFuture;
     }
     }
 
 
-    @Override
-    public ResultSet getUninterruptibly() {
+    public TbResultSet getUninterruptibly() {
         return getSafe();
         return getSafe();
     }
     }
 
 
-    @Override
-    public ResultSet getUninterruptibly(long timeout, TimeUnit unit) throws TimeoutException {
+    public TbResultSet getUninterruptibly(long timeout, TimeUnit unit) throws TimeoutException {
         return getSafe(timeout, unit);
         return getSafe(timeout, unit);
     }
     }
 
 
@@ -61,12 +59,12 @@ public class TbResultSetFuture implements ResultSetFuture {
     }
     }
 
 
     @Override
     @Override
-    public ResultSet get() throws InterruptedException, ExecutionException {
+    public TbResultSet get() throws InterruptedException, ExecutionException {
         return mainFuture.get();
         return mainFuture.get();
     }
     }
 
 
     @Override
     @Override
-    public ResultSet get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+    public TbResultSet get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
         return mainFuture.get(timeout, unit);
         return mainFuture.get(timeout, unit);
     }
     }
 
 
@@ -75,7 +73,7 @@ public class TbResultSetFuture implements ResultSetFuture {
         mainFuture.addListener(listener, executor);
         mainFuture.addListener(listener, executor);
     }
     }
 
 
-    private ResultSet getSafe() {
+    private TbResultSet getSafe() {
         try {
         try {
             return mainFuture.get();
             return mainFuture.get();
         } catch (InterruptedException | ExecutionException e) {
         } catch (InterruptedException | ExecutionException e) {
@@ -83,7 +81,7 @@ public class TbResultSetFuture implements ResultSetFuture {
         }
         }
     }
     }
 
 
-    private ResultSet getSafe(long timeout, TimeUnit unit) throws TimeoutException {
+    private TbResultSet getSafe(long timeout, TimeUnit unit) throws TimeoutException {
         try {
         try {
             return mainFuture.get(timeout, unit);
             return mainFuture.get(timeout, unit);
         } catch (InterruptedException | ExecutionException e) {
         } catch (InterruptedException | ExecutionException e) {

@@ -67,8 +67,8 @@
             <scope>test</scope>
             <scope>test</scope>
         </dependency>
         </dependency>
         <dependency>
         <dependency>
-            <groupId>com.datastax.cassandra</groupId>
-            <artifactId>cassandra-driver-core</artifactId>
+            <groupId>com.datastax.oss</groupId>
+            <artifactId>java-driver-core</artifactId>
             <scope>test</scope>
             <scope>test</scope>
         </dependency>
         </dependency>
     </dependencies>
     </dependencies>

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.common.data;
 package org.thingsboard.server.common.data;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.junit.Assert;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runner.RunWith;
@@ -61,8 +61,8 @@ public class UUIDConverterTest {
                 before = tmp;
                 before = tmp;
             }
             }
 
 
-            String beforeStr = UUIDConverter.fromTimeUUID(UUIDs.startOf(before));
-            String afterStr = UUIDConverter.fromTimeUUID(UUIDs.startOf(after));
+            String beforeStr = UUIDConverter.fromTimeUUID(Uuids.startOf(before));
+            String afterStr = UUIDConverter.fromTimeUUID(Uuids.startOf(after));
 
 
             if (afterStr.compareTo(beforeStr) < 0) {
             if (afterStr.compareTo(beforeStr) < 0) {
                 System.out.println("Before: " + before + " | " + beforeStr);
                 System.out.println("Before: " + before + " | " + beforeStr);

@@ -54,6 +54,9 @@ public class TbKafkaConsumerTemplate<T extends TbQueueMsg> extends AbstractTbQue
         if (groupId != null) {
         if (groupId != null) {
             props.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
             props.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
         }
         }
+        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, settings.getMaxPollRecords());
+        props.put(ConsumerConfig.MAX_PARTITION_FETCH_BYTES_CONFIG, settings.getMaxPartitionFetchBytes());
+        props.put(ConsumerConfig.FETCH_MAX_BYTES_CONFIG, settings.getFetchMaxBytes());
         props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, autoCommit);
         props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, autoCommit);
         props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, autoCommitIntervalMs);
         props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, autoCommitIntervalMs);
         props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
         props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

@@ -55,6 +55,18 @@ public class TbKafkaSettings {
     @Getter
     @Getter
     private short replicationFactor;
     private short replicationFactor;
 
 
+    @Value("${queue.kafka.max_poll_records:8192}")
+    @Getter
+    private int maxPollRecords;
+
+    @Value("${queue.kafka.max_partition_fetch_bytes:16777216}")
+    @Getter
+    private int maxPartitionFetchBytes;
+
+    @Value("${queue.kafka.fetch_max_bytes:134217728}")
+    @Getter
+    private  int fetchMaxBytes;
+
     @Value("${kafka.other:#{null}}")
     @Value("${kafka.other:#{null}}")
     private List<TbKafkaProperty> other;
     private List<TbKafkaProperty> other;
 
 

@@ -391,6 +391,7 @@ public class JsonConverter {
                     break;
                     break;
                 case JSON_V:
                 case JSON_V:
                     result.add(de.getKv().getKey(), JSON_PARSER.parse(de.getKv().getJsonV()));
                     result.add(de.getKv().getKey(), JSON_PARSER.parse(de.getKv().getJsonV()));
+                    break;
                 default:
                 default:
                     throw new IllegalArgumentException("Unsupported data type: " + de.getKv().getType());
                     throw new IllegalArgumentException("Unsupported data type: " + de.getKv().getType());
             }
             }

@@ -120,18 +120,18 @@
             <groupId>org.springframework.security</groupId>
             <groupId>org.springframework.security</groupId>
             <artifactId>spring-security-oauth2-client</artifactId>
             <artifactId>spring-security-oauth2-client</artifactId>
         </dependency>
         </dependency>
-		<dependency>
-			<groupId>com.datastax.cassandra</groupId>
-			<artifactId>cassandra-driver-core</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>com.datastax.cassandra</groupId>
-			<artifactId>cassandra-driver-mapping</artifactId>
-		</dependency>
-		<dependency>
-			<groupId>com.datastax.cassandra</groupId>
-			<artifactId>cassandra-driver-extras</artifactId>
-		</dependency>
+        <dependency>
+            <groupId>com.datastax.oss</groupId>
+            <artifactId>java-driver-core</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.datastax.oss</groupId>
+            <artifactId>java-driver-query-builder</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>io.dropwizard.metrics</groupId>
+            <artifactId>metrics-jmx</artifactId>
+        </dependency>
         <dependency>
         <dependency>
             <groupId>io.takari.junit</groupId>
             <groupId>io.takari.junit</groupId>
             <artifactId>takari-cpsuite</artifactId>
             <artifactId>takari-cpsuite</artifactId>
@@ -149,6 +149,10 @@
                     <groupId>org.slf4j</groupId>
                     <groupId>org.slf4j</groupId>
                     <artifactId>slf4j-log4j12</artifactId>
                     <artifactId>slf4j-log4j12</artifactId>
                 </exclusion>
                 </exclusion>
+                <exclusion>
+                    <groupId>org.hibernate</groupId>
+                    <artifactId>hibernate-validator</artifactId>
+                </exclusion>
             </exclusions>
             </exclusions>
             <scope>test</scope>
             <scope>test</scope>
         </dependency>
         </dependency>

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao;
 package org.thingsboard.server.dao;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.PageRequest;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Pageable;
@@ -49,7 +49,7 @@ public abstract class DaoUtil {
 
 
     public static String startTimeToId(Long startTime) {
     public static String startTimeToId(Long startTime) {
         if (startTime != null) {
         if (startTime != null) {
-            UUID startOf = UUIDs.startOf(startTime);
+            UUID startOf = Uuids.startOf(startTime);
             return UUIDConverter.fromTimeUUID(startOf);
             return UUIDConverter.fromTimeUUID(startOf);
         } else {
         } else {
             return null;
             return null;
@@ -58,7 +58,7 @@ public abstract class DaoUtil {
 
 
     public static String endTimeToId(Long endTime) {
     public static String endTimeToId(Long endTime) {
         if (endTime != null) {
         if (endTime != null) {
-            UUID endOf = UUIDs.endOf(endTime);
+            UUID endOf = Uuids.endOf(endTime);
             return UUIDConverter.fromTimeUUID(endOf);
             return UUIDConverter.fromTimeUUID(endOf);
         } else {
         } else {
             return null;
             return null;

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.audit;
 package org.thingsboard.server.dao.audit;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import com.fasterxml.jackson.databind.node.ArrayNode;
@@ -296,7 +296,7 @@ public class AuditLogServiceImpl implements AuditLogService {
                                          ActionStatus actionStatus,
                                          ActionStatus actionStatus,
                                          String actionFailureDetails) {
                                          String actionFailureDetails) {
         AuditLog result = new AuditLog();
         AuditLog result = new AuditLog();
-        result.setId(new AuditLogId(UUIDs.timeBased()));
+        result.setId(new AuditLogId(Uuids.timeBased()));
         result.setTenantId(tenantId);
         result.setTenantId(tenantId);
         result.setEntityId(entityId);
         result.setEntityId(entityId);
         result.setEntityName(entityName);
         result.setEntityName(entityName);

-/**
- * 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.model;
-
-import com.datastax.driver.mapping.annotations.Column;
-import com.datastax.driver.mapping.annotations.PartitionKey;
-import com.datastax.driver.mapping.annotations.Table;
-import org.thingsboard.server.common.data.EntitySubtype;
-import org.thingsboard.server.common.data.EntityType;
-import org.thingsboard.server.common.data.id.TenantId;
-import org.thingsboard.server.dao.model.type.EntityTypeCodec;
-
-import java.util.UUID;
-
-import static org.thingsboard.server.dao.model.ModelConstants.ENTITY_SUBTYPE_COLUMN_FAMILY_NAME;
-import static org.thingsboard.server.dao.model.ModelConstants.ENTITY_SUBTYPE_ENTITY_TYPE_PROPERTY;
-import static org.thingsboard.server.dao.model.ModelConstants.ENTITY_SUBTYPE_TENANT_ID_PROPERTY;
-import static org.thingsboard.server.dao.model.ModelConstants.ENTITY_SUBTYPE_TYPE_PROPERTY;
-
-@Table(name = ENTITY_SUBTYPE_COLUMN_FAMILY_NAME)
-public class EntitySubtypeEntity {
-
-    @PartitionKey(value = 0)
-    @Column(name = ENTITY_SUBTYPE_TENANT_ID_PROPERTY)
-    private UUID tenantId;
-
-    @PartitionKey(value = 1)
-    @Column(name = ENTITY_SUBTYPE_ENTITY_TYPE_PROPERTY, codec = EntityTypeCodec.class)
-    private EntityType entityType;
-
-    @PartitionKey(value = 2)
-    @Column(name = ENTITY_SUBTYPE_TYPE_PROPERTY)
-    private String type;
-
-    public EntitySubtypeEntity() {
-        super();
-    }
-
-    public EntitySubtypeEntity(EntitySubtype entitySubtype) {
-        this.tenantId = entitySubtype.getTenantId().getId();
-        this.entityType = entitySubtype.getEntityType();
-        this.type = entitySubtype.getType();
-    }
-
-    public UUID getTenantId() {
-        return tenantId;
-    }
-
-    public void setTenantId(UUID tenantId) {
-        this.tenantId = tenantId;
-    }
-
-    public EntityType getEntityType() {
-        return entityType;
-    }
-
-    public void setEntityType(EntityType entityType) {
-        this.entityType = entityType;
-    }
-
-    public String getType() {
-        return type;
-    }
-
-    public void setType(String type) {
-        this.type = type;
-    }
-
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-
-        EntitySubtypeEntity that = (EntitySubtypeEntity) o;
-
-        if (tenantId != null ? !tenantId.equals(that.tenantId) : that.tenantId != null) return false;
-        if (entityType != that.entityType) return false;
-        return type != null ? type.equals(that.type) : that.type == null;
-
-    }
-
-    @Override
-    public int hashCode() {
-        int result = tenantId != null ? tenantId.hashCode() : 0;
-        result = 31 * result + (entityType != null ? entityType.hashCode() : 0);
-        result = 31 * result + (type != null ? type.hashCode() : 0);
-        return result;
-    }
-
-    @Override
-    public String toString() {
-        final StringBuilder sb = new StringBuilder("EntitySubtypeEntity{");
-        sb.append("tenantId=").append(tenantId);
-        sb.append(", entityType=").append(entityType);
-        sb.append(", type='").append(type).append('\'');
-        sb.append('}');
-        return sb.toString();
-    }
-
-    public EntitySubtype toEntitySubtype() {
-        EntitySubtype entitySubtype = new EntitySubtype();
-        entitySubtype.setTenantId(new TenantId(tenantId));
-        entitySubtype.setEntityType(entityType);
-        entitySubtype.setType(type);
-        return entitySubtype;
-    }
-}

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model;
 package org.thingsboard.server.dao.model;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.apache.commons.lang3.ArrayUtils;
 import org.apache.commons.lang3.ArrayUtils;
 import org.thingsboard.server.common.data.UUIDConverter;
 import org.thingsboard.server.common.data.UUIDConverter;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
@@ -28,7 +28,7 @@ public class ModelConstants {
     private ModelConstants() {
     private ModelConstants() {
     }
     }
 
 
-    public static final UUID NULL_UUID = UUIDs.startOf(0);
+    public static final UUID NULL_UUID = Uuids.startOf(0);
     public static final String NULL_UUID_STR = UUIDConverter.fromTimeUUID(NULL_UUID);
     public static final String NULL_UUID_STR = UUIDConverter.fromTimeUUID(NULL_UUID);
     public static final TenantId SYSTEM_TENANT = new TenantId(ModelConstants.NULL_UUID);
     public static final TenantId SYSTEM_TENANT = new TenantId(ModelConstants.NULL_UUID);
 
 

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
@@ -154,7 +154,7 @@ public abstract class AbstractAlarmEntity<T extends Alarm> extends BaseSqlEntity
 
 
     protected Alarm toAlarm() {
     protected Alarm toAlarm() {
         Alarm alarm = new Alarm(new AlarmId(UUIDConverter.fromString(id)));
         Alarm alarm = new Alarm(new AlarmId(UUIDConverter.fromString(id)));
-        alarm.setCreatedTime(UUIDs.unixTimestamp(UUIDConverter.fromString(id)));
+        alarm.setCreatedTime(Uuids.unixTimestamp(UUIDConverter.fromString(id)));
         if (tenantId != null) {
         if (tenantId != null) {
             alarm.setTenantId(new TenantId(UUIDConverter.fromString(tenantId)));
             alarm.setTenantId(new TenantId(UUIDConverter.fromString(tenantId)));
         }
         }

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
@@ -116,7 +116,7 @@ public abstract class AbstractAssetEntity<T extends Asset> extends BaseSqlEntity
 
 
     protected Asset toAsset() {
     protected Asset toAsset() {
         Asset asset = new Asset(new AssetId(UUIDConverter.fromString(id)));
         Asset asset = new Asset(new AssetId(UUIDConverter.fromString(id)));
-        asset.setCreatedTime(UUIDs.unixTimestamp(UUIDConverter.fromString(id)));
+        asset.setCreatedTime(Uuids.unixTimestamp(UUIDConverter.fromString(id)));
         if (tenantId != null) {
         if (tenantId != null) {
             asset.setTenantId(new TenantId(UUIDConverter.fromString(tenantId)));
             asset.setTenantId(new TenantId(UUIDConverter.fromString(tenantId)));
         }
         }

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
@@ -104,7 +104,7 @@ public abstract class AbstractDeviceEntity<T extends Device> extends BaseSqlEnti
 
 
     protected Device toDevice() {
     protected Device toDevice() {
         Device device = new Device(new DeviceId(getUuid()));
         Device device = new Device(new DeviceId(getUuid()));
-        device.setCreatedTime(UUIDs.unixTimestamp(getUuid()));
+        device.setCreatedTime(Uuids.unixTimestamp(getUuid()));
         if (tenantId != null) {
         if (tenantId != null) {
             device.setTenantId(new TenantId(toUUID(tenantId)));
             device.setTenantId(new TenantId(toUUID(tenantId)));
         }
         }

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.Data;
 import lombok.Data;
@@ -147,7 +147,7 @@ public abstract class AbstractEntityViewEntity<T extends EntityView> extends Bas
 
 
     protected EntityView toEntityView() {
     protected EntityView toEntityView() {
         EntityView entityView = new EntityView(new EntityViewId(getUuid()));
         EntityView entityView = new EntityView(new EntityViewId(getUuid()));
-        entityView.setCreatedTime(UUIDs.unixTimestamp(getUuid()));
+        entityView.setCreatedTime(Uuids.unixTimestamp(getUuid()));
 
 
         if (entityId != null) {
         if (entityId != null) {
             entityView.setEntityId(EntityIdFactory.getByTypeAndId(entityType.name(), toUUID(entityId).toString()));
             entityView.setEntityId(EntityIdFactory.getByTypeAndId(entityType.name(), toUUID(entityId).toString()));

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
@@ -65,10 +65,10 @@ public final class AdminSettingsEntity extends BaseSqlEntity<AdminSettings> impl
     @Override
     @Override
     public AdminSettings toData() {
     public AdminSettings toData() {
         AdminSettings adminSettings = new AdminSettings(new AdminSettingsId(UUIDConverter.fromString(id)));
         AdminSettings adminSettings = new AdminSettings(new AdminSettingsId(UUIDConverter.fromString(id)));
-        adminSettings.setCreatedTime(UUIDs.unixTimestamp(UUIDConverter.fromString(id)));
+        adminSettings.setCreatedTime(Uuids.unixTimestamp(UUIDConverter.fromString(id)));
         adminSettings.setKey(key);
         adminSettings.setKey(key);
         adminSettings.setJsonValue(jsonValue);
         adminSettings.setJsonValue(jsonValue);
         return adminSettings;
         return adminSettings;
     }
     }
 
 
-}
+}

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
@@ -129,7 +129,7 @@ public class AuditLogEntity extends BaseSqlEntity<AuditLog> implements BaseEntit
     @Override
     @Override
     public AuditLog toData() {
     public AuditLog toData() {
         AuditLog auditLog = new AuditLog(new AuditLogId(this.getUuid()));
         AuditLog auditLog = new AuditLog(new AuditLogId(this.getUuid()));
-        auditLog.setCreatedTime(UUIDs.unixTimestamp(this.getUuid()));
+        auditLog.setCreatedTime(Uuids.unixTimestamp(this.getUuid()));
         if (tenantId != null) {
         if (tenantId != null) {
             auditLog.setTenantId(new TenantId(toUUID(tenantId)));
             auditLog.setTenantId(new TenantId(toUUID(tenantId)));
         }
         }

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
@@ -112,7 +112,7 @@ public final class CustomerEntity extends BaseSqlEntity<Customer> implements Sea
     @Override
     @Override
     public Customer toData() {
     public Customer toData() {
         Customer customer = new Customer(new CustomerId(this.getUuid()));
         Customer customer = new Customer(new CustomerId(this.getUuid()));
-        customer.setCreatedTime(UUIDs.unixTimestamp(this.getUuid()));
+        customer.setCreatedTime(Uuids.unixTimestamp(this.getUuid()));
         customer.setTenantId(new TenantId(UUIDConverter.fromString(tenantId)));
         customer.setTenantId(new TenantId(UUIDConverter.fromString(tenantId)));
         customer.setTitle(title);
         customer.setTitle(title);
         customer.setCountry(country);
         customer.setCountry(country);
@@ -126,4 +126,4 @@ public final class CustomerEntity extends BaseSqlEntity<Customer> implements Sea
         customer.setAdditionalInfo(additionalInfo);
         customer.setAdditionalInfo(additionalInfo);
         return customer;
         return customer;
     }
     }
-}
+}

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
@@ -104,7 +104,7 @@ public final class DashboardEntity extends BaseSqlEntity<Dashboard> implements S
     @Override
     @Override
     public Dashboard toData() {
     public Dashboard toData() {
         Dashboard dashboard = new Dashboard(new DashboardId(this.getUuid()));
         Dashboard dashboard = new Dashboard(new DashboardId(this.getUuid()));
-        dashboard.setCreatedTime(UUIDs.unixTimestamp(this.getUuid()));
+        dashboard.setCreatedTime(Uuids.unixTimestamp(this.getUuid()));
         if (tenantId != null) {
         if (tenantId != null) {
             dashboard.setTenantId(new TenantId(toUUID(tenantId)));
             dashboard.setTenantId(new TenantId(toUUID(tenantId)));
         }
         }
@@ -119,4 +119,4 @@ public final class DashboardEntity extends BaseSqlEntity<Dashboard> implements S
         dashboard.setConfiguration(configuration);
         dashboard.setConfiguration(configuration);
         return dashboard;
         return dashboard;
     }
     }
-}
+}

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectMapper;
@@ -98,7 +98,7 @@ public class DashboardInfoEntity extends BaseSqlEntity<DashboardInfo> implements
     @Override
     @Override
     public DashboardInfo toData() {
     public DashboardInfo toData() {
         DashboardInfo dashboardInfo = new DashboardInfo(new DashboardId(this.getUuid()));
         DashboardInfo dashboardInfo = new DashboardInfo(new DashboardId(this.getUuid()));
-        dashboardInfo.setCreatedTime(UUIDs.unixTimestamp(this.getUuid()));
+        dashboardInfo.setCreatedTime(Uuids.unixTimestamp(this.getUuid()));
         if (tenantId != null) {
         if (tenantId != null) {
             dashboardInfo.setTenantId(new TenantId(toUUID(tenantId)));
             dashboardInfo.setTenantId(new TenantId(toUUID(tenantId)));
         }
         }
@@ -113,4 +113,4 @@ public class DashboardInfoEntity extends BaseSqlEntity<DashboardInfo> implements
         return dashboardInfo;
         return dashboardInfo;
     }
     }
 
 
-}
+}

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
 import org.thingsboard.server.common.data.id.DeviceCredentialsId;
 import org.thingsboard.server.common.data.id.DeviceCredentialsId;
@@ -70,7 +70,7 @@ public final class DeviceCredentialsEntity extends BaseSqlEntity<DeviceCredentia
     @Override
     @Override
     public DeviceCredentials toData() {
     public DeviceCredentials toData() {
         DeviceCredentials deviceCredentials = new DeviceCredentials(new DeviceCredentialsId(this.getUuid()));
         DeviceCredentials deviceCredentials = new DeviceCredentials(new DeviceCredentialsId(this.getUuid()));
-        deviceCredentials.setCreatedTime(UUIDs.unixTimestamp(this.getUuid()));
+        deviceCredentials.setCreatedTime(Uuids.unixTimestamp(this.getUuid()));
         if (deviceId != null) {
         if (deviceId != null) {
             deviceCredentials.setDeviceId(new DeviceId(toUUID(deviceId)));
             deviceCredentials.setDeviceId(new DeviceId(toUUID(deviceId)));
         }
         }
@@ -80,4 +80,4 @@ public final class DeviceCredentialsEntity extends BaseSqlEntity<DeviceCredentia
         return deviceCredentials;
         return deviceCredentials;
     }
     }
 
 
-}
+}

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
@@ -103,7 +103,7 @@ public class EventEntity  extends BaseSqlEntity<Event> implements BaseEntity<Eve
     @Override
     @Override
     public Event toData() {
     public Event toData() {
         Event event = new Event(new EventId(this.getUuid()));
         Event event = new Event(new EventId(this.getUuid()));
-        event.setCreatedTime(UUIDs.unixTimestamp(this.getUuid()));
+        event.setCreatedTime(Uuids.unixTimestamp(this.getUuid()));
         event.setTenantId(new TenantId(toUUID(tenantId)));
         event.setTenantId(new TenantId(toUUID(tenantId)));
         event.setEntityId(EntityIdFactory.getByTypeAndUuid(entityType, toUUID(entityId)));
         event.setEntityId(EntityIdFactory.getByTypeAndUuid(entityType, toUUID(entityId)));
         event.setBody(body);
         event.setBody(body);

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
@@ -101,7 +101,7 @@ public class RuleChainEntity extends BaseSqlEntity<RuleChain> implements SearchT
     @Override
     @Override
     public RuleChain toData() {
     public RuleChain toData() {
         RuleChain ruleChain = new RuleChain(new RuleChainId(this.getUuid()));
         RuleChain ruleChain = new RuleChain(new RuleChainId(this.getUuid()));
-        ruleChain.setCreatedTime(UUIDs.unixTimestamp(this.getUuid()));
+        ruleChain.setCreatedTime(Uuids.unixTimestamp(this.getUuid()));
         ruleChain.setTenantId(new TenantId(toUUID(tenantId)));
         ruleChain.setTenantId(new TenantId(toUUID(tenantId)));
         ruleChain.setName(name);
         ruleChain.setName(name);
         if (firstRuleNodeId != null) {
         if (firstRuleNodeId != null) {

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
@@ -95,7 +95,7 @@ public class RuleNodeEntity extends BaseSqlEntity<RuleNode> implements SearchTex
     @Override
     @Override
     public RuleNode toData() {
     public RuleNode toData() {
         RuleNode ruleNode = new RuleNode(new RuleNodeId(this.getUuid()));
         RuleNode ruleNode = new RuleNode(new RuleNodeId(this.getUuid()));
-        ruleNode.setCreatedTime(UUIDs.unixTimestamp(this.getUuid()));
+        ruleNode.setCreatedTime(Uuids.unixTimestamp(this.getUuid()));
         if (ruleChainId != null) {
         if (ruleChainId != null) {
             ruleNode.setRuleChainId(new RuleChainId(toUUID(ruleChainId)));
             ruleNode.setRuleChainId(new RuleChainId(toUUID(ruleChainId)));
         }
         }

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
@@ -122,7 +122,7 @@ public final class TenantEntity extends BaseSqlEntity<Tenant> implements SearchT
     @Override
     @Override
     public Tenant toData() {
     public Tenant toData() {
         Tenant tenant = new Tenant(new TenantId(this.getUuid()));
         Tenant tenant = new Tenant(new TenantId(this.getUuid()));
-        tenant.setCreatedTime(UUIDs.unixTimestamp(this.getUuid()));
+        tenant.setCreatedTime(Uuids.unixTimestamp(this.getUuid()));
         tenant.setTitle(title);
         tenant.setTitle(title);
         tenant.setRegion(region);
         tenant.setRegion(region);
         tenant.setCountry(country);
         tenant.setCountry(country);
@@ -140,4 +140,4 @@ public final class TenantEntity extends BaseSqlEntity<Tenant> implements SearchT
     }
     }
 
 
 
 
-}
+}

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
 import org.thingsboard.server.common.data.id.UserCredentialsId;
 import org.thingsboard.server.common.data.id.UserCredentialsId;
@@ -70,7 +70,7 @@ public final class UserCredentialsEntity extends BaseSqlEntity<UserCredentials>
     @Override
     @Override
     public UserCredentials toData() {
     public UserCredentials toData() {
         UserCredentials userCredentials = new UserCredentials(new UserCredentialsId(this.getUuid()));
         UserCredentials userCredentials = new UserCredentials(new UserCredentialsId(this.getUuid()));
-        userCredentials.setCreatedTime(UUIDs.unixTimestamp(this.getUuid()));
+        userCredentials.setCreatedTime(Uuids.unixTimestamp(this.getUuid()));
         if (userId != null) {
         if (userId != null) {
             userCredentials.setUserId(new UserId(toUUID(userId)));
             userCredentials.setUserId(new UserId(toUUID(userId)));
         }
         }
@@ -81,4 +81,4 @@ public final class UserCredentialsEntity extends BaseSqlEntity<UserCredentials>
         return userCredentials;
         return userCredentials;
     }
     }
 
 
-}
+}

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
@@ -109,7 +109,7 @@ public class UserEntity extends BaseSqlEntity<User> implements SearchTextEntity<
     @Override
     @Override
     public User toData() {
     public User toData() {
         User user = new User(new UserId(this.getUuid()));
         User user = new User(new UserId(this.getUuid()));
-        user.setCreatedTime(UUIDs.unixTimestamp(this.getUuid()));
+        user.setCreatedTime(Uuids.unixTimestamp(this.getUuid()));
         user.setAuthority(authority);
         user.setAuthority(authority);
         if (tenantId != null) {
         if (tenantId != null) {
             user.setTenantId(new TenantId(fromString(tenantId)));
             user.setTenantId(new TenantId(fromString(tenantId)));

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
@@ -76,7 +76,7 @@ public final class WidgetTypeEntity  extends BaseSqlEntity<WidgetType> implement
     @Override
     @Override
     public WidgetType toData() {
     public WidgetType toData() {
         WidgetType widgetType = new WidgetType(new WidgetTypeId(this.getUuid()));
         WidgetType widgetType = new WidgetType(new WidgetTypeId(this.getUuid()));
-        widgetType.setCreatedTime(UUIDs.unixTimestamp(this.getUuid()));
+        widgetType.setCreatedTime(Uuids.unixTimestamp(this.getUuid()));
         if (tenantId != null) {
         if (tenantId != null) {
             widgetType.setTenantId(new TenantId(toUUID(tenantId)));
             widgetType.setTenantId(new TenantId(toUUID(tenantId)));
         }
         }

@@ -16,7 +16,7 @@
 package org.thingsboard.server.dao.model.sql;
 package org.thingsboard.server.dao.model.sql;
 
 
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import lombok.Data;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.EqualsAndHashCode;
 import org.thingsboard.server.common.data.UUIDConverter;
 import org.thingsboard.server.common.data.UUIDConverter;
@@ -77,7 +77,7 @@ public final class WidgetsBundleEntity extends BaseSqlEntity<WidgetsBundle> impl
     @Override
     @Override
     public WidgetsBundle toData() {
     public WidgetsBundle toData() {
         WidgetsBundle widgetsBundle = new WidgetsBundle(new WidgetsBundleId(UUIDConverter.fromString(id)));
         WidgetsBundle widgetsBundle = new WidgetsBundle(new WidgetsBundleId(UUIDConverter.fromString(id)));
-        widgetsBundle.setCreatedTime(UUIDs.unixTimestamp(UUIDConverter.fromString(id)));
+        widgetsBundle.setCreatedTime(Uuids.unixTimestamp(UUIDConverter.fromString(id)));
         if (tenantId != null) {
         if (tenantId != null) {
             widgetsBundle.setTenantId(new TenantId(UUIDConverter.fromString(tenantId)));
             widgetsBundle.setTenantId(new TenantId(UUIDConverter.fromString(tenantId)));
         }
         }

-/**
- * 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.model.wrapper;
-
-
-import com.datastax.driver.core.ResultSet;
-
-public class EntityResultSet<T> {
-
-  private ResultSet resultSet;
-  private T entity;
-
-  public EntityResultSet(ResultSet resultSet, T entity) {
-    this.resultSet = resultSet;
-    this.entity = entity;
-  }
-
-  public T getEntity() {
-    return entity;
-  }
-
-  public boolean wasApplied() {
-    return resultSet.wasApplied();
-  }
-}

@@ -15,9 +15,11 @@
  */
  */
 package org.thingsboard.server.dao.nosql;
 package org.thingsboard.server.dao.nosql;
 
 
-import com.datastax.driver.core.ResultSet;
-import com.datastax.driver.core.ResultSetFuture;
+import com.datastax.oss.driver.api.core.cql.AsyncResultSet;
+import com.datastax.oss.driver.api.core.cql.Row;
 import com.google.common.base.Function;
 import com.google.common.base.Function;
+import com.google.common.collect.Lists;
+import com.google.common.util.concurrent.AsyncFunction;
 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 org.thingsboard.common.util.ThingsBoardThreadFactory;
 import org.thingsboard.common.util.ThingsBoardThreadFactory;
@@ -25,8 +27,11 @@ import org.thingsboard.common.util.ThingsBoardThreadFactory;
 import javax.annotation.Nullable;
 import javax.annotation.Nullable;
 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.concurrent.ExecutorService;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Executors;
+import java.util.stream.Collectors;
 
 
 /**
 /**
  * Created by ashvayka on 21.02.17.
  * Created by ashvayka on 21.02.17.
@@ -47,13 +52,28 @@ public abstract class CassandraAbstractAsyncDao extends CassandraAbstractDao {
         }
         }
     }
     }
 
 
-    protected <T> ListenableFuture<T> getFuture(ResultSetFuture future, java.util.function.Function<ResultSet, T> transformer) {
-        return Futures.transform(future, new Function<ResultSet, T>() {
+    protected <T> ListenableFuture<T> getFuture(TbResultSetFuture future, java.util.function.Function<TbResultSet, T> transformer) {
+        return Futures.transform(future, new Function<TbResultSet, T>() {
             @Nullable
             @Nullable
             @Override
             @Override
-            public T apply(@Nullable ResultSet input) {
+            public T apply(@Nullable TbResultSet input) {
                 return transformer.apply(input);
                 return transformer.apply(input);
             }
             }
         }, readResultsProcessingExecutor);
         }, readResultsProcessingExecutor);
     }
     }
+
+    protected <T> ListenableFuture<T> getFutureAsync(TbResultSetFuture future, com.google.common.util.concurrent.AsyncFunction<TbResultSet, T> transformer) {
+        return Futures.transformAsync(future, new AsyncFunction<TbResultSet, T>() {
+            @Nullable
+            @Override
+            public ListenableFuture<T> apply(@Nullable TbResultSet input) {
+                try {
+                    return transformer.apply(input);
+                } catch (Exception e) {
+                    return Futures.immediateFailedFuture(e);
+                }
+            }
+        }, readResultsProcessingExecutor);
+    }
+
 }
 }

@@ -15,16 +15,17 @@
  */
  */
 package org.thingsboard.server.dao.nosql;
 package org.thingsboard.server.dao.nosql;
 
 
-import com.datastax.driver.core.*;
-import com.datastax.driver.core.exceptions.CodecNotFoundException;
+import com.datastax.oss.driver.api.core.ConsistencyLevel;
+import com.datastax.oss.driver.api.core.cql.AsyncResultSet;
+import com.datastax.oss.driver.api.core.cql.BoundStatement;
+import com.datastax.oss.driver.api.core.cql.PreparedStatement;
+import com.datastax.oss.driver.api.core.cql.Statement;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.dao.cassandra.CassandraCluster;
 import org.thingsboard.server.dao.cassandra.CassandraCluster;
-import org.thingsboard.server.dao.model.type.ComponentLifecycleStateCodec;
-import org.thingsboard.server.dao.model.type.EntityTypeCodec;
-import org.thingsboard.server.dao.model.type.JsonCodec;
+import org.thingsboard.server.dao.cassandra.guava.GuavaSession;
 
 
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.ConcurrentMap;
@@ -41,20 +42,16 @@ public abstract class CassandraAbstractDao {
     @Autowired
     @Autowired
     private CassandraBufferedRateExecutor rateLimiter;
     private CassandraBufferedRateExecutor rateLimiter;
 
 
-    private Session session;
+    private GuavaSession session;
 
 
     private ConsistencyLevel defaultReadLevel;
     private ConsistencyLevel defaultReadLevel;
     private ConsistencyLevel defaultWriteLevel;
     private ConsistencyLevel defaultWriteLevel;
 
 
-    private Session getSession() {
+    private GuavaSession getSession() {
         if (session == null) {
         if (session == null) {
             session = cluster.getSession();
             session = cluster.getSession();
             defaultReadLevel = cluster.getDefaultReadConsistencyLevel();
             defaultReadLevel = cluster.getDefaultReadConsistencyLevel();
             defaultWriteLevel = cluster.getDefaultWriteConsistencyLevel();
             defaultWriteLevel = cluster.getDefaultWriteConsistencyLevel();
-            CodecRegistry registry = session.getCluster().getConfiguration().getCodecRegistry();
-            registerCodecIfNotFound(registry, new JsonCodec());
-            registerCodecIfNotFound(registry, new ComponentLifecycleStateCodec());
-            registerCodecIfNotFound(registry, new EntityTypeCodec());
         }
         }
         return session;
         return session;
     }
     }
@@ -63,38 +60,30 @@ public abstract class CassandraAbstractDao {
         return preparedStatementMap.computeIfAbsent(query, i -> getSession().prepare(i));
         return preparedStatementMap.computeIfAbsent(query, i -> getSession().prepare(i));
     }
     }
 
 
-    private void registerCodecIfNotFound(CodecRegistry registry, TypeCodec<?> codec) {
-        try {
-            registry.codecFor(codec.getCqlType(), codec.getJavaType());
-        } catch (CodecNotFoundException e) {
-            registry.register(codec);
-        }
-    }
-
-    protected ResultSet executeRead(TenantId tenantId, Statement statement) {
+    protected AsyncResultSet executeRead(TenantId tenantId, Statement statement) {
         return execute(tenantId, statement, defaultReadLevel);
         return execute(tenantId, statement, defaultReadLevel);
     }
     }
 
 
-    protected ResultSet executeWrite(TenantId tenantId, Statement statement) {
+    protected AsyncResultSet executeWrite(TenantId tenantId, Statement statement) {
         return execute(tenantId, statement, defaultWriteLevel);
         return execute(tenantId, statement, defaultWriteLevel);
     }
     }
 
 
-    protected ResultSetFuture executeAsyncRead(TenantId tenantId, Statement statement) {
+    protected TbResultSetFuture executeAsyncRead(TenantId tenantId, Statement statement) {
         return executeAsync(tenantId, statement, defaultReadLevel);
         return executeAsync(tenantId, statement, defaultReadLevel);
     }
     }
 
 
-    protected ResultSetFuture executeAsyncWrite(TenantId tenantId, Statement statement) {
+    protected TbResultSetFuture executeAsyncWrite(TenantId tenantId, Statement statement) {
         return executeAsync(tenantId, statement, defaultWriteLevel);
         return executeAsync(tenantId, statement, defaultWriteLevel);
     }
     }
 
 
-    private ResultSet execute(TenantId tenantId, Statement statement, ConsistencyLevel level) {
+    private AsyncResultSet execute(TenantId tenantId, Statement statement, ConsistencyLevel level) {
         if (log.isDebugEnabled()) {
         if (log.isDebugEnabled()) {
             log.debug("Execute cassandra statement {}", statementToString(statement));
             log.debug("Execute cassandra statement {}", statementToString(statement));
         }
         }
         return executeAsync(tenantId, statement, level).getUninterruptibly();
         return executeAsync(tenantId, statement, level).getUninterruptibly();
     }
     }
 
 
-    private ResultSetFuture executeAsync(TenantId tenantId, Statement statement, ConsistencyLevel level) {
+    private TbResultSetFuture executeAsync(TenantId tenantId, Statement statement, ConsistencyLevel level) {
         if (log.isDebugEnabled()) {
         if (log.isDebugEnabled()) {
             log.debug("Execute cassandra async statement {}", statementToString(statement));
             log.debug("Execute cassandra async statement {}", statementToString(statement));
         }
         }
@@ -106,9 +95,9 @@ public abstract class CassandraAbstractDao {
 
 
     private static String statementToString(Statement statement) {
     private static String statementToString(Statement statement) {
         if (statement instanceof BoundStatement) {
         if (statement instanceof BoundStatement) {
-            return ((BoundStatement) statement).preparedStatement().getQueryString();
+            return ((BoundStatement) statement).getPreparedStatement().getQuery();
         } else {
         } else {
             return statement.toString();
             return statement.toString();
         }
         }
     }
     }
-}
+}

@@ -15,8 +15,8 @@
  */
  */
 package org.thingsboard.server.dao.nosql;
 package org.thingsboard.server.dao.nosql;
 
 
-import com.datastax.driver.core.ResultSet;
-import com.datastax.driver.core.ResultSetFuture;
+import com.datastax.oss.driver.api.core.cql.AsyncResultSet;
+import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.SettableFuture;
 import com.google.common.util.concurrent.SettableFuture;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -39,7 +39,7 @@ import java.util.Map;
 @Component
 @Component
 @Slf4j
 @Slf4j
 @NoSqlAnyDao
 @NoSqlAnyDao
-public class CassandraBufferedRateExecutor extends AbstractBufferedRateExecutor<CassandraStatementTask, ResultSetFuture, ResultSet> {
+public class CassandraBufferedRateExecutor extends AbstractBufferedRateExecutor<CassandraStatementTask, TbResultSetFuture, TbResultSet> {
 
 
     @Autowired
     @Autowired
     private EntityService entityService;
     private EntityService entityService;
@@ -107,19 +107,22 @@ public class CassandraBufferedRateExecutor extends AbstractBufferedRateExecutor<
     }
     }
 
 
     @Override
     @Override
-    protected SettableFuture<ResultSet> create() {
+    protected SettableFuture<TbResultSet> create() {
         return SettableFuture.create();
         return SettableFuture.create();
     }
     }
 
 
     @Override
     @Override
-    protected ResultSetFuture wrap(CassandraStatementTask task, SettableFuture<ResultSet> future) {
+    protected TbResultSetFuture wrap(CassandraStatementTask task, SettableFuture<TbResultSet> future) {
         return new TbResultSetFuture(future);
         return new TbResultSetFuture(future);
     }
     }
 
 
     @Override
     @Override
-    protected ResultSetFuture execute(AsyncTaskContext<CassandraStatementTask, ResultSet> taskCtx) {
+    protected ListenableFuture<TbResultSet> execute(AsyncTaskContext<CassandraStatementTask, TbResultSet> taskCtx) {
         CassandraStatementTask task = taskCtx.getTask();
         CassandraStatementTask task = taskCtx.getTask();
-        return task.getSession().executeAsync(task.getStatement());
+        return task.executeAsync(
+                statement ->
+                    this.submit(new CassandraStatementTask(task.getTenantId(), task.getSession(), statement))
+        );
     }
     }
 
 
 }
 }

-/**
- * 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.nosql;
-
-import com.datastax.driver.core.ResultSet;
-import com.datastax.driver.core.ResultSetFuture;
-import com.datastax.driver.core.Session;
-import com.datastax.driver.core.Statement;
-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 com.google.common.util.concurrent.Uninterruptibles;
-import org.thingsboard.server.dao.exception.BufferLimitException;
-import org.thingsboard.server.dao.util.AsyncRateLimiter;
-
-import javax.annotation.Nullable;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Executor;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-
-public class RateLimitedResultSetFuture implements ResultSetFuture {
-
-    private final ListenableFuture<ResultSetFuture> originalFuture;
-    private final ListenableFuture<Void> rateLimitFuture;
-
-    public RateLimitedResultSetFuture(Session session, AsyncRateLimiter rateLimiter, Statement statement) {
-        this.rateLimitFuture = Futures.catchingAsync(rateLimiter.acquireAsync(), Throwable.class, t -> {
-            if (!(t instanceof BufferLimitException)) {
-                rateLimiter.release();
-            }
-            return Futures.immediateFailedFuture(t);
-        }, MoreExecutors.directExecutor());
-        this.originalFuture = Futures.transform(rateLimitFuture,
-                i -> executeAsyncWithRelease(rateLimiter, session, statement), MoreExecutors.directExecutor());
-
-    }
-
-    @Override
-    public ResultSet getUninterruptibly() {
-        return safeGet().getUninterruptibly();
-    }
-
-    @Override
-    public ResultSet getUninterruptibly(long timeout, TimeUnit unit) throws TimeoutException {
-        long rateLimitStart = System.nanoTime();
-        ResultSetFuture resultSetFuture = null;
-        try {
-            resultSetFuture = originalFuture.get(timeout, unit);
-        } catch (InterruptedException | ExecutionException e) {
-            throw new IllegalStateException(e);
-        }
-        long rateLimitDurationNano = System.nanoTime() - rateLimitStart;
-        long innerTimeoutNano = unit.toNanos(timeout) - rateLimitDurationNano;
-        if (innerTimeoutNano > 0) {
-            return resultSetFuture.getUninterruptibly(innerTimeoutNano, TimeUnit.NANOSECONDS);
-        }
-        throw new TimeoutException("Timeout waiting for task.");
-    }
-
-    @Override
-    public boolean cancel(boolean mayInterruptIfRunning) {
-        if (originalFuture.isDone()) {
-            return safeGet().cancel(mayInterruptIfRunning);
-        } else {
-            return originalFuture.cancel(mayInterruptIfRunning);
-        }
-    }
-
-    @Override
-    public boolean isCancelled() {
-        if (originalFuture.isDone()) {
-            return safeGet().isCancelled();
-        }
-
-        return originalFuture.isCancelled();
-    }
-
-    @Override
-    public boolean isDone() {
-        return originalFuture.isDone() && safeGet().isDone();
-    }
-
-    @Override
-    public ResultSet get() throws InterruptedException, ExecutionException {
-        return safeGet().get();
-    }
-
-    @Override
-    public ResultSet get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
-        long rateLimitStart = System.nanoTime();
-        ResultSetFuture resultSetFuture = originalFuture.get(timeout, unit);
-        long rateLimitDurationNano = System.nanoTime() - rateLimitStart;
-        long innerTimeoutNano = unit.toNanos(timeout) - rateLimitDurationNano;
-        if (innerTimeoutNano > 0) {
-            return resultSetFuture.get(innerTimeoutNano, TimeUnit.NANOSECONDS);
-        }
-        throw new TimeoutException("Timeout waiting for task.");
-    }
-
-    @Override
-    public void addListener(Runnable listener, Executor executor) {
-        originalFuture.addListener(() -> {
-            try {
-                ResultSetFuture resultSetFuture = Uninterruptibles.getUninterruptibly(originalFuture);
-                resultSetFuture.addListener(listener, executor);
-            } catch (CancellationException | ExecutionException e) {
-                Futures.immediateFailedFuture(e).addListener(listener, executor);
-            }
-        }, executor);
-    }
-
-    private ResultSetFuture safeGet() {
-        try {
-            return originalFuture.get();
-        } catch (InterruptedException | ExecutionException e) {
-            throw new IllegalStateException(e);
-        }
-    }
-
-    private ResultSetFuture executeAsyncWithRelease(AsyncRateLimiter rateLimiter, Session session, Statement statement) {
-        try {
-            ResultSetFuture resultSetFuture = session.executeAsync(statement);
-            Futures.addCallback(resultSetFuture, new FutureCallback<ResultSet>() {
-                @Override
-                public void onSuccess(@Nullable ResultSet result) {
-                    rateLimiter.release();
-                }
-
-                @Override
-                public void onFailure(Throwable t) {
-                    rateLimiter.release();
-                }
-            }, MoreExecutors.directExecutor());
-            return resultSetFuture;
-        } catch (RuntimeException re) {
-            rateLimiter.release();
-            throw re;
-        }
-    }
-}

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.sql;
 package org.thingsboard.server.dao.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Lists;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
@@ -59,7 +59,7 @@ public abstract class JpaAbstractDao<E extends BaseEntity<D>, D>
         setSearchText(entity);
         setSearchText(entity);
         log.debug("Saving entity {}", entity);
         log.debug("Saving entity {}", entity);
         if (entity.getUuid() == null) {
         if (entity.getUuid() == null) {
-            entity.setUuid(UUIDs.timeBased());
+            entity.setUuid(Uuids.timeBased());
         }
         }
         entity = getCrudRepository().save(entity);
         entity = getCrudRepository().save(entity);
         return DaoUtil.getData(entity);
         return DaoUtil.getData(entity);

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.sql;
 package org.thingsboard.server.dao.sql;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.springframework.data.jpa.domain.Specification;
 import org.springframework.data.jpa.domain.Specification;
 import org.thingsboard.server.common.data.UUIDConverter;
 import org.thingsboard.server.common.data.UUIDConverter;
 import org.thingsboard.server.common.data.page.TimePageLink;
 import org.thingsboard.server.common.data.page.TimePageLink;
@@ -40,12 +40,12 @@ public abstract class JpaAbstractSearchTimeDao<E extends BaseEntity<D>, D> exten
             public Predicate toPredicate(Root<T> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
             public Predicate toPredicate(Root<T> root, CriteriaQuery<?> criteriaQuery, CriteriaBuilder criteriaBuilder) {
                 List<Predicate> predicates = new ArrayList<>();
                 List<Predicate> predicates = new ArrayList<>();
                 if (pageLink.getStartTime() != null) {
                 if (pageLink.getStartTime() != null) {
-                    UUID startOf = UUIDs.startOf(pageLink.getStartTime());
+                    UUID startOf = Uuids.startOf(pageLink.getStartTime());
                     Predicate lowerBound = criteriaBuilder.greaterThanOrEqualTo(root.get(idColumn), UUIDConverter.fromTimeUUID(startOf));
                     Predicate lowerBound = criteriaBuilder.greaterThanOrEqualTo(root.get(idColumn), UUIDConverter.fromTimeUUID(startOf));
                     predicates.add(lowerBound);
                     predicates.add(lowerBound);
                 }
                 }
                 if (pageLink.getEndTime() != null) {
                 if (pageLink.getEndTime() != null) {
-                    UUID endOf = UUIDs.endOf(pageLink.getEndTime());
+                    UUID endOf = Uuids.endOf(pageLink.getEndTime());
                     Predicate upperBound = criteriaBuilder.lessThanOrEqualTo(root.get(idColumn), UUIDConverter.fromTimeUUID(endOf));
                     Predicate upperBound = criteriaBuilder.lessThanOrEqualTo(root.get(idColumn), UUIDConverter.fromTimeUUID(endOf));
                     predicates.add(upperBound);
                     predicates.add(upperBound);
                 }
                 }

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.sql.component;
 package org.thingsboard.server.dao.sql.component;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.data.repository.CrudRepository;
 import org.springframework.stereotype.Component;
 import org.springframework.stereotype.Component;
@@ -64,7 +64,7 @@ public class JpaBaseComponentDescriptorDao extends JpaAbstractSearchTextDao<Comp
     @Override
     @Override
     public Optional<ComponentDescriptor> saveIfNotExist(TenantId tenantId, ComponentDescriptor component) {
     public Optional<ComponentDescriptor> saveIfNotExist(TenantId tenantId, ComponentDescriptor component) {
         if (component.getId() == null) {
         if (component.getId() == null) {
-            component.setId(new ComponentDescriptorId(UUIDs.timeBased()));
+            component.setId(new ComponentDescriptorId(Uuids.timeBased()));
         }
         }
         if (!componentDescriptorRepository.existsById(UUIDConverter.fromTimeUUID(component.getId().getId()))) {
         if (!componentDescriptorRepository.existsById(UUIDConverter.fromTimeUUID(component.getId().getId()))) {
             ComponentDescriptorEntity componentDescriptorEntity = new ComponentDescriptorEntity(component);
             ComponentDescriptorEntity componentDescriptorEntity = new ComponentDescriptorEntity(component);

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.sql.event;
 package org.thingsboard.server.dao.sql.event;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.google.common.util.concurrent.ListenableFuture;
 import com.google.common.util.concurrent.ListenableFuture;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -75,7 +75,7 @@ public class JpaBaseEventDao extends JpaAbstractSearchTimeDao<EventEntity, Event
     public Event save(TenantId tenantId, Event event) {
     public Event save(TenantId tenantId, Event event) {
         log.debug("Save event [{}] ", event);
         log.debug("Save event [{}] ", event);
         if (event.getId() == null) {
         if (event.getId() == null) {
-            event.setId(new EventId(UUIDs.timeBased()));
+            event.setId(new EventId(Uuids.timeBased()));
         }
         }
         if (StringUtils.isEmpty(event.getUid())) {
         if (StringUtils.isEmpty(event.getUid())) {
             event.setUid(event.getId().toString());
             event.setUid(event.getId().toString());
@@ -87,7 +87,7 @@ public class JpaBaseEventDao extends JpaAbstractSearchTimeDao<EventEntity, Event
     public ListenableFuture<Event> saveAsync(Event event) {
     public ListenableFuture<Event> saveAsync(Event event) {
         log.debug("Save event [{}] ", event);
         log.debug("Save event [{}] ", event);
         if (event.getId() == null) {
         if (event.getId() == null) {
-            event.setId(new EventId(UUIDs.timeBased()));
+            event.setId(new EventId(Uuids.timeBased()));
         }
         }
         if (StringUtils.isEmpty(event.getUid())) {
         if (StringUtils.isEmpty(event.getUid())) {
             event.setUid(event.getId().toString());
             event.setUid(event.getId().toString());
@@ -152,7 +152,7 @@ public class JpaBaseEventDao extends JpaAbstractSearchTimeDao<EventEntity, Event
             entity.setTenantId(UUIDConverter.fromTimeUUID(systemTenantId));
             entity.setTenantId(UUIDConverter.fromTimeUUID(systemTenantId));
         }
         }
         if (entity.getUuid() == null) {
         if (entity.getUuid() == null) {
-            entity.setUuid(UUIDs.timeBased());
+            entity.setUuid(Uuids.timeBased());
         }
         }
         if (StringUtils.isEmpty(entity.getEventUid())) {
         if (StringUtils.isEmpty(entity.getEventUid())) {
             entity.setEventUid(entity.getUuid().toString());
             entity.setEventUid(entity.getUuid().toString());

@@ -15,8 +15,10 @@
  */
  */
 package org.thingsboard.server.dao.timeseries;
 package org.thingsboard.server.dao.timeseries;
 
 
-import com.datastax.driver.core.ResultSet;
-import com.datastax.driver.core.Row;
+import com.datastax.oss.driver.api.core.cql.AsyncResultSet;
+import com.datastax.oss.driver.api.core.cql.Row;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.thingsboard.server.common.data.kv.Aggregation;
 import org.thingsboard.server.common.data.kv.Aggregation;
 import org.thingsboard.server.common.data.kv.BasicTsKvEntry;
 import org.thingsboard.server.common.data.kv.BasicTsKvEntry;
@@ -27,16 +29,19 @@ import org.thingsboard.server.common.data.kv.JsonDataEntry;
 import org.thingsboard.server.common.data.kv.LongDataEntry;
 import org.thingsboard.server.common.data.kv.LongDataEntry;
 import org.thingsboard.server.common.data.kv.StringDataEntry;
 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.nosql.TbResultSet;
 
 
 import javax.annotation.Nullable;
 import javax.annotation.Nullable;
 import java.util.List;
 import java.util.List;
 import java.util.Optional;
 import java.util.Optional;
+import java.util.concurrent.Executor;
+import java.util.stream.Collectors;
 
 
 /**
 /**
  * Created by ashvayka on 20.02.17.
  * Created by ashvayka on 20.02.17.
  */
  */
 @Slf4j
 @Slf4j
-public class AggregatePartitionsFunction implements com.google.common.base.Function<List<ResultSet>, Optional<TsKvEntry>> {
+public class AggregatePartitionsFunction implements com.google.common.util.concurrent.AsyncFunction<List<TbResultSet>, Optional<TsKvEntry>> {
 
 
     private static final int LONG_CNT_POS = 0;
     private static final int LONG_CNT_POS = 0;
     private static final int DOUBLE_CNT_POS = 1;
     private static final int DOUBLE_CNT_POS = 1;
@@ -52,33 +57,39 @@ public class AggregatePartitionsFunction implements com.google.common.base.Funct
     private final Aggregation aggregation;
     private final Aggregation aggregation;
     private final String key;
     private final String key;
     private final long ts;
     private final long ts;
+    private final Executor executor;
 
 
-    public AggregatePartitionsFunction(Aggregation aggregation, String key, long ts) {
+    public AggregatePartitionsFunction(Aggregation aggregation, String key, long ts, Executor executor) {
         this.aggregation = aggregation;
         this.aggregation = aggregation;
         this.key = key;
         this.key = key;
         this.ts = ts;
         this.ts = ts;
+        this.executor = executor;
     }
     }
 
 
     @Override
     @Override
-    public Optional<TsKvEntry> apply(@Nullable List<ResultSet> rsList) {
-        try {
-            log.trace("[{}][{}][{}] Going to aggregate data", key, ts, aggregation);
-            if (rsList == null || rsList.isEmpty()) {
-                return Optional.empty();
-            }
-
-            AggregationResult aggResult = new AggregationResult();
-
-            for (ResultSet rs : rsList) {
-                for (Row row : rs.all()) {
-                    processResultSetRow(row, aggResult);
+    public ListenableFuture<Optional<TsKvEntry>> apply(@Nullable List<TbResultSet> rsList) {
+    log.trace("[{}][{}][{}] Going to aggregate data", key, ts, aggregation);
+    if (rsList == null || rsList.isEmpty()) {
+        return Futures.immediateFuture(Optional.empty());
+    }
+    return Futures.transform(
+        Futures.allAsList(
+            rsList.stream().map(rs -> rs.allRows(this.executor))
+                .collect(Collectors.toList())),
+        rowsList -> {
+            try {
+                AggregationResult aggResult = new AggregationResult();
+                for (List<Row> rs : rowsList) {
+                    for (Row row : rs) {
+                        processResultSetRow(row, aggResult);
+                    }
                 }
                 }
+                return processAggregationResult(aggResult);
+            } catch (Exception e) {
+                log.error("[{}][{}][{}] Failed to aggregate data", key, ts, aggregation, e);
+                return Optional.empty();
             }
             }
-            return processAggregationResult(aggResult);
-        } catch (Exception e) {
-            log.error("[{}][{}][{}] Failed to aggregate data", key, ts, aggregation, e);
-            return Optional.empty();
-        }
+        }, this.executor);
     }
     }
 
 
     private void processResultSetRow(Row row, AggregationResult aggResult) {
     private void processResultSetRow(Row row, AggregationResult aggResult) {
@@ -181,7 +192,7 @@ public class AggregatePartitionsFunction implements com.google.common.base.Funct
 
 
     private Boolean getBooleanValue(Row row) {
     private Boolean getBooleanValue(Row row) {
         if (aggregation == Aggregation.MIN || aggregation == Aggregation.MAX) {
         if (aggregation == Aggregation.MIN || aggregation == Aggregation.MAX) {
-            return row.getBool(BOOL_POS);
+            return row.getBoolean(BOOL_POS);
         } else {
         } else {
             return null; //NOSONAR, null is used for further comparison
             return null; //NOSONAR, null is used for further comparison
         }
         }

@@ -15,14 +15,14 @@
  */
  */
 package org.thingsboard.server.dao.timeseries;
 package org.thingsboard.server.dao.timeseries;
 
 
-import com.datastax.driver.core.BoundStatement;
-import com.datastax.driver.core.PreparedStatement;
-import com.datastax.driver.core.ResultSet;
-import com.datastax.driver.core.ResultSetFuture;
-import com.datastax.driver.core.Row;
-import com.datastax.driver.core.Statement;
-import com.datastax.driver.core.querybuilder.QueryBuilder;
-import com.datastax.driver.core.querybuilder.Select;
+import com.datastax.oss.driver.api.core.cql.AsyncResultSet;
+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.datastax.oss.driver.api.querybuilder.select.Select;
 import com.google.common.base.Function;
 import com.google.common.base.Function;
 import com.google.common.util.concurrent.AsyncFunction;
 import com.google.common.util.concurrent.AsyncFunction;
 import com.google.common.util.concurrent.FutureCallback;
 import com.google.common.util.concurrent.FutureCallback;
@@ -52,6 +52,8 @@ 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.CassandraAbstractAsyncDao;
+import org.thingsboard.server.dao.nosql.TbResultSet;
+import org.thingsboard.server.dao.nosql.TbResultSetFuture;
 import org.thingsboard.server.dao.util.NoSqlTsDao;
 import org.thingsboard.server.dao.util.NoSqlTsDao;
 
 
 import javax.annotation.Nullable;
 import javax.annotation.Nullable;
@@ -69,7 +71,7 @@ import java.util.Optional;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
 import java.util.stream.Collectors;
 
 
-import static com.datastax.driver.core.querybuilder.QueryBuilder.eq;
+import static com.datastax.oss.driver.api.querybuilder.QueryBuilder.literal;
 
 
 /**
 /**
  * @author Andrew Shvayka
  * @author Andrew Shvayka
@@ -189,8 +191,8 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         if (isFixedPartitioning()) { //no need to fetch partitions from DB
         if (isFixedPartitioning()) { //no need to fetch partitions from DB
             return Futures.immediateFuture(FIXED_PARTITION);
             return Futures.immediateFuture(FIXED_PARTITION);
         }
         }
-        ResultSetFuture partitionsFuture = fetchPartitions(tenantId, entityId, query.getKey(), minPartition, maxPartition);
-        return Futures.transform(partitionsFuture, getPartitionsArrayFunction(), readResultsProcessingExecutor);
+        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) {
@@ -225,20 +227,41 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
             resultFuture.set(cursor.getData());
             resultFuture.set(cursor.getData());
         } else {
         } else {
             PreparedStatement proto = getFetchStmt(Aggregation.NONE, cursor.getOrderBy());
             PreparedStatement proto = getFetchStmt(Aggregation.NONE, cursor.getOrderBy());
-            BoundStatement stmt = proto.bind();
-            stmt.setString(0, cursor.getEntityType());
-            stmt.setUUID(1, cursor.getEntityId());
-            stmt.setString(2, cursor.getKey());
-            stmt.setLong(3, cursor.getNextPartition());
-            stmt.setLong(4, cursor.getStartTs());
-            stmt.setLong(5, cursor.getEndTs());
-            stmt.setInt(6, cursor.getCurrentLimit());
-
-            Futures.addCallback(executeAsyncRead(tenantId, stmt), new FutureCallback<ResultSet>() {
+            BoundStatementBuilder stmtBuilder = new BoundStatementBuilder(proto.bind());
+
+            stmtBuilder.setString(0, cursor.getEntityType());
+            stmtBuilder.setUuid(1, cursor.getEntityId());
+            stmtBuilder.setString(2, cursor.getKey());
+            stmtBuilder.setLong(3, cursor.getNextPartition());
+            stmtBuilder.setLong(4, cursor.getStartTs());
+            stmtBuilder.setLong(5, cursor.getEndTs());
+            stmtBuilder.setInt(6, cursor.getCurrentLimit());
+
+            BoundStatement stmt = stmtBuilder.build();
+
+            Futures.addCallback(executeAsyncRead(tenantId, stmt), new FutureCallback<TbResultSet>() {
                 @Override
                 @Override
-                public void onSuccess(@Nullable ResultSet result) {
-                    cursor.addData(convertResultToTsKvEntryList(result == null ? Collections.emptyList() : result.all()));
-                    findAllAsyncSequentiallyWithLimit(tenantId, cursor, resultFuture);
+                public void onSuccess(@Nullable TbResultSet result) {
+                    if (result == null) {
+                        cursor.addData(convertResultToTsKvEntryList(Collections.emptyList()));
+                        findAllAsyncSequentiallyWithLimit(tenantId, cursor, resultFuture);
+                    } else {
+                        Futures.addCallback(result.allRows(readResultsProcessingExecutor), new FutureCallback<List<Row>>() {
+
+                            @Override
+                            public void onSuccess(@Nullable List<Row> result) {
+                                cursor.addData(convertResultToTsKvEntryList(result == null ? Collections.emptyList() : result));
+                                findAllAsyncSequentiallyWithLimit(tenantId, cursor, resultFuture);
+                            }
+
+                            @Override
+                            public void onFailure(Throwable t) {
+                                log.error("[{}][{}] Failed to fetch data for query {}-{}", stmt, t);
+                            }
+                        }, readResultsProcessingExecutor);
+
+
+                    }
                 }
                 }
 
 
                 @Override
                 @Override
@@ -256,31 +279,35 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         final long endTs = query.getEndTs();
         final long endTs = query.getEndTs();
         final long ts = startTs + (endTs - startTs) / 2;
         final long ts = startTs + (endTs - startTs) / 2;
         ListenableFuture<List<Long>> partitionsListFuture = getPartitionsFuture(tenantId, query, entityId, minPartition, maxPartition);
         ListenableFuture<List<Long>> partitionsListFuture = getPartitionsFuture(tenantId, query, entityId, minPartition, maxPartition);
-        ListenableFuture<List<ResultSet>> aggregationChunks = Futures.transformAsync(partitionsListFuture,
+        ListenableFuture<List<TbResultSet>> aggregationChunks = Futures.transformAsync(partitionsListFuture,
                 getFetchChunksAsyncFunction(tenantId, entityId, key, aggregation, startTs, endTs), readResultsProcessingExecutor);
                 getFetchChunksAsyncFunction(tenantId, entityId, key, aggregation, startTs, endTs), readResultsProcessingExecutor);
 
 
-        return Futures.transform(aggregationChunks, new AggregatePartitionsFunction(aggregation, key, ts), readResultsProcessingExecutor);
+        return Futures.transformAsync(aggregationChunks, new AggregatePartitionsFunction(aggregation, key, ts, readResultsProcessingExecutor), readResultsProcessingExecutor);
     }
     }
 
 
-    private Function<ResultSet, List<Long>> getPartitionsArrayFunction() {
-        return rows -> rows.all().stream()
-                .map(row -> row.getLong(ModelConstants.PARTITION_COLUMN)).collect(Collectors.toList());
+    private AsyncFunction<TbResultSet, List<Long>> getPartitionsArrayFunction() {
+        return rs ->
+            Futures.transform(rs.allRows(readResultsProcessingExecutor), rows ->
+                rows.stream()
+                .map(row -> row.getLong(ModelConstants.PARTITION_COLUMN)).collect(Collectors.toList()),
+                    readResultsProcessingExecutor);
     }
     }
 
 
-    private AsyncFunction<List<Long>, List<ResultSet>> 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) {
         return partitions -> {
         return partitions -> {
             try {
             try {
                 PreparedStatement proto = getFetchStmt(aggregation, DESC_ORDER);
                 PreparedStatement proto = getFetchStmt(aggregation, DESC_ORDER);
-                List<ResultSetFuture> futures = new ArrayList<>(partitions.size());
+                List<TbResultSetFuture> futures = new ArrayList<>(partitions.size());
                 for (Long partition : partitions) {
                 for (Long partition : partitions) {
                     log.trace("Fetching data for partition [{}] for entityType {} and entityId {}", partition, entityId.getEntityType(), entityId.getId());
                     log.trace("Fetching data for partition [{}] for entityType {} and entityId {}", partition, entityId.getEntityType(), entityId.getId());
-                    BoundStatement stmt = proto.bind();
-                    stmt.setString(0, entityId.getEntityType().name());
-                    stmt.setUUID(1, entityId.getId());
-                    stmt.setString(2, key);
-                    stmt.setLong(3, partition);
-                    stmt.setLong(4, startTs);
-                    stmt.setLong(5, endTs);
+                    BoundStatementBuilder stmtBuilder = new BoundStatementBuilder(proto.bind());
+                    stmtBuilder.setString(0, entityId.getEntityType().name());
+                    stmtBuilder.setUuid(1, entityId.getId());
+                    stmtBuilder.setString(2, key);
+                    stmtBuilder.setLong(3, partition);
+                    stmtBuilder.setLong(4, startTs);
+                    stmtBuilder.setLong(5, endTs);
+                    BoundStatement stmt = stmtBuilder.build();
                     log.debug(GENERATED_QUERY_FOR_ENTITY_TYPE_AND_ENTITY_ID, stmt, entityId.getEntityType(), entityId.getId());
                     log.debug(GENERATED_QUERY_FOR_ENTITY_TYPE_AND_ENTITY_ID, stmt, entityId.getEntityType(), entityId.getId());
                     futures.add(executeAsyncRead(tenantId, stmt));
                     futures.add(executeAsyncRead(tenantId, stmt));
                 }
                 }
@@ -294,21 +321,23 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
 
 
     @Override
     @Override
     public ListenableFuture<TsKvEntry> findLatest(TenantId tenantId, EntityId entityId, String key) {
     public ListenableFuture<TsKvEntry> findLatest(TenantId tenantId, EntityId entityId, String key) {
-        BoundStatement stmt = getFindLatestStmt().bind();
-        stmt.setString(0, entityId.getEntityType().name());
-        stmt.setUUID(1, entityId.getId());
-        stmt.setString(2, 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());
         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()));
         return getFuture(executeAsyncRead(tenantId, stmt), rs -> convertResultToTsKvEntry(key, rs.one()));
     }
     }
 
 
     @Override
     @Override
     public ListenableFuture<List<TsKvEntry>> findAllLatest(TenantId tenantId, EntityId entityId) {
     public ListenableFuture<List<TsKvEntry>> findAllLatest(TenantId tenantId, EntityId entityId) {
-        BoundStatement stmt = getFindAllLatestStmt().bind();
-        stmt.setString(0, entityId.getEntityType().name());
-        stmt.setUUID(1, entityId.getId());
+        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());
         log.debug(GENERATED_QUERY_FOR_ENTITY_TYPE_AND_ENTITY_ID, stmt, entityId.getEntityType(), entityId.getId());
-        return getFuture(executeAsyncRead(tenantId, stmt), rs -> convertResultToTsKvEntryList(rs.all()));
+        return getFutureAsync(executeAsyncRead(tenantId, stmt), rs -> convertAsyncResultSetToTsKvEntryList(rs));
     }
     }
 
 
     @Override
     @Override
@@ -320,16 +349,17 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         if (setNullValuesEnabled) {
         if (setNullValuesEnabled) {
             processSetNullValues(tenantId, entityId, tsKvEntry, ttl, futures, partition, type);
             processSetNullValues(tenantId, entityId, tsKvEntry, ttl, futures, partition, type);
         }
         }
-        BoundStatement stmt = (ttl == 0 ? getSaveStmt(type) : getSaveTtlStmt(type)).bind();
-        stmt.setString(0, entityId.getEntityType().name())
-                .setUUID(1, entityId.getId())
+        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())
                 .setString(2, tsKvEntry.getKey())
                 .setLong(3, partition)
                 .setLong(3, partition)
                 .setLong(4, tsKvEntry.getTs());
                 .setLong(4, tsKvEntry.getTs());
-        addValue(tsKvEntry, stmt, 5);
+        addValue(tsKvEntry, stmtBuilder, 5);
         if (ttl > 0) {
         if (ttl > 0) {
-            stmt.setInt(6, (int) ttl);
+            stmtBuilder.setInt(6, (int) ttl);
         }
         }
+        BoundStatement stmt = stmtBuilder.build();
         futures.add(getFuture(executeAsyncWrite(tenantId, stmt), rs -> null));
         futures.add(getFuture(executeAsyncWrite(tenantId, stmt), rs -> null));
         return Futures.transform(Futures.allAsList(futures), result -> null, MoreExecutors.directExecutor());
         return Futures.transform(Futures.allAsList(futures), result -> null, MoreExecutors.directExecutor());
     }
     }
@@ -370,16 +400,17 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
     }
     }
 
 
     private ListenableFuture<Void> saveNull(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry, long ttl, long partition, DataType type) {
     private ListenableFuture<Void> saveNull(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry, long ttl, long partition, DataType type) {
-        BoundStatement stmt = (ttl == 0 ? getSaveStmt(type) : getSaveTtlStmt(type)).bind();
-        stmt.setString(0, entityId.getEntityType().name())
-                .setUUID(1, entityId.getId())
+        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())
                 .setString(2, tsKvEntry.getKey())
                 .setLong(3, partition)
                 .setLong(3, partition)
                 .setLong(4, tsKvEntry.getTs());
                 .setLong(4, tsKvEntry.getTs());
-        stmt.setToNull(getColumnName(type));
+        stmtBuilder.setToNull(getColumnName(type));
         if (ttl > 0) {
         if (ttl > 0) {
-            stmt.setInt(6, (int) ttl);
+            stmtBuilder.setInt(6, (int) ttl);
         }
         }
+        BoundStatement stmt = stmtBuilder.build();
         return getFuture(executeAsyncWrite(tenantId, stmt), rs -> null);
         return getFuture(executeAsyncWrite(tenantId, stmt), rs -> null);
     }
     }
 
 
@@ -391,14 +422,15 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         ttl = computeTtl(ttl);
         ttl = computeTtl(ttl);
         long partition = toPartitionTs(tsKvEntryTs);
         long partition = toPartitionTs(tsKvEntryTs);
         log.debug("Saving partition {} for the entity [{}-{}] and key {}", partition, entityId.getEntityType(), entityId.getId(), key);
         log.debug("Saving partition {} for the entity [{}-{}] and key {}", partition, entityId.getEntityType(), entityId.getId(), key);
-        BoundStatement stmt = (ttl == 0 ? getPartitionInsertStmt() : getPartitionInsertTtlStmt()).bind();
-        stmt = stmt.setString(0, entityId.getEntityType().name())
-                .setUUID(1, entityId.getId())
+        BoundStatementBuilder stmtBuilder = new BoundStatementBuilder((ttl == 0 ? getPartitionInsertStmt() : getPartitionInsertTtlStmt()).bind());
+        stmtBuilder.setString(0, entityId.getEntityType().name())
+                .setUuid(1, entityId.getId())
                 .setLong(2, partition)
                 .setLong(2, partition)
                 .setString(3, key);
                 .setString(3, key);
         if (ttl > 0) {
         if (ttl > 0) {
-            stmt.setInt(4, (int) ttl);
+            stmtBuilder.setInt(4, (int) ttl);
         }
         }
+        BoundStatement stmt = stmtBuilder.build();
         return getFuture(executeAsyncWrite(tenantId, stmt), rs -> null);
         return getFuture(executeAsyncWrite(tenantId, stmt), rs -> null);
     }
     }
 
 
@@ -415,9 +447,9 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
 
 
     @Override
     @Override
     public ListenableFuture<Void> saveLatest(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry) {
     public ListenableFuture<Void> saveLatest(TenantId tenantId, EntityId entityId, TsKvEntry tsKvEntry) {
-        BoundStatement stmt = getLatestStmt().bind()
-                .setString(0, entityId.getEntityType().name())
-                .setUUID(1, entityId.getId())
+        BoundStatementBuilder stmtBuilder = new BoundStatementBuilder(getLatestStmt().bind());
+        stmtBuilder.setString(0, entityId.getEntityType().name())
+                .setUuid(1, entityId.getId())
                 .setString(2, tsKvEntry.getKey())
                 .setString(2, tsKvEntry.getKey())
                 .setLong(3, tsKvEntry.getTs())
                 .setLong(3, tsKvEntry.getTs())
                 .set(4, tsKvEntry.getBooleanValue().orElse(null), Boolean.class)
                 .set(4, tsKvEntry.getBooleanValue().orElse(null), Boolean.class)
@@ -426,10 +458,11 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
                 .set(7, tsKvEntry.getDoubleValue().orElse(null), Double.class);
                 .set(7, tsKvEntry.getDoubleValue().orElse(null), Double.class);
         Optional<String> jsonV = tsKvEntry.getJsonValue();
         Optional<String> jsonV = tsKvEntry.getJsonValue();
         if (jsonV.isPresent()) {
         if (jsonV.isPresent()) {
-            stmt.setString(8, tsKvEntry.getJsonValue().get());
+            stmtBuilder.setString(8, tsKvEntry.getJsonValue().get());
         } else {
         } else {
-            stmt.setToNull(8);
+            stmtBuilder.setToNull(8);
         }
         }
+        BoundStatement stmt = stmtBuilder.build();
 
 
         return getFuture(executeAsyncWrite(tenantId, stmt), rs -> null);
         return getFuture(executeAsyncWrite(tenantId, stmt), rs -> null);
     }
     }
@@ -439,10 +472,10 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         long minPartition = toPartitionTs(query.getStartTs());
         long minPartition = toPartitionTs(query.getStartTs());
         long maxPartition = toPartitionTs(query.getEndTs());
         long maxPartition = toPartitionTs(query.getEndTs());
 
 
-        ResultSetFuture partitionsFuture = fetchPartitions(tenantId, entityId, query.getKey(), minPartition, maxPartition);
+        TbResultSetFuture partitionsFuture = fetchPartitions(tenantId, entityId, query.getKey(), minPartition, maxPartition);
 
 
         final SimpleListenableFuture<Void> resultFuture = new SimpleListenableFuture<>();
         final SimpleListenableFuture<Void> resultFuture = new SimpleListenableFuture<>();
-        final ListenableFuture<List<Long>> partitionsListFuture = Futures.transform(partitionsFuture, getPartitionsArrayFunction(), readResultsProcessingExecutor);
+        final ListenableFuture<List<Long>> partitionsListFuture = Futures.transformAsync(partitionsFuture, getPartitionsArrayFunction(), readResultsProcessingExecutor);
 
 
         Futures.addCallback(partitionsListFuture, new FutureCallback<List<Long>>() {
         Futures.addCallback(partitionsListFuture, new FutureCallback<List<Long>>() {
             @Override
             @Override
@@ -464,17 +497,19 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
             resultFuture.set(null);
             resultFuture.set(null);
         } else {
         } else {
             PreparedStatement proto = getDeleteStmt();
             PreparedStatement proto = getDeleteStmt();
-            BoundStatement stmt = proto.bind();
-            stmt.setString(0, cursor.getEntityType());
-            stmt.setUUID(1, cursor.getEntityId());
-            stmt.setString(2, cursor.getKey());
-            stmt.setLong(3, cursor.getNextPartition());
-            stmt.setLong(4, cursor.getStartTs());
-            stmt.setLong(5, cursor.getEndTs());
-
-            Futures.addCallback(executeAsyncWrite(tenantId, stmt), new FutureCallback<ResultSet>() {
+            BoundStatementBuilder stmtBuilder = new BoundStatementBuilder(proto.bind());
+            stmtBuilder.setString(0, cursor.getEntityType());
+            stmtBuilder.setUuid(1, cursor.getEntityId());
+            stmtBuilder.setString(2, cursor.getKey());
+            stmtBuilder.setLong(3, cursor.getNextPartition());
+            stmtBuilder.setLong(4, cursor.getStartTs());
+            stmtBuilder.setLong(5, cursor.getEndTs());
+
+            BoundStatement stmt = stmtBuilder.build();
+
+            Futures.addCallback(executeAsyncWrite(tenantId, stmt), new FutureCallback<AsyncResultSet>() {
                 @Override
                 @Override
-                public void onSuccess(@Nullable ResultSet result) {
+                public void onSuccess(@Nullable AsyncResultSet result) {
                     deleteAsync(tenantId, cursor, resultFuture);
                     deleteAsync(tenantId, cursor, resultFuture);
                 }
                 }
 
 
@@ -568,10 +603,10 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
     }
     }
 
 
     private ListenableFuture<Void> deleteLatest(TenantId tenantId, EntityId entityId, String key) {
     private ListenableFuture<Void> deleteLatest(TenantId tenantId, EntityId entityId, String key) {
-        Statement delete = QueryBuilder.delete().all().from(ModelConstants.TS_KV_LATEST_CF)
-                .where(eq(ModelConstants.ENTITY_TYPE_COLUMN, entityId.getEntityType()))
-                .and(eq(ModelConstants.ENTITY_ID_COLUMN, entityId.getId()))
-                .and(eq(ModelConstants.KEY_COLUMN, 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());
         log.debug("Remove request: {}", delete.toString());
         return getFuture(executeAsyncWrite(tenantId, delete), rs -> null);
         return getFuture(executeAsyncWrite(tenantId, delete), rs -> null);
     }
     }
@@ -583,10 +618,10 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         if (minPartition == maxPartition) {
         if (minPartition == maxPartition) {
             return Futures.immediateFuture(null);
             return Futures.immediateFuture(null);
         } else {
         } else {
-            ResultSetFuture partitionsFuture = fetchPartitions(tenantId, entityId, query.getKey(), minPartition, maxPartition);
+            TbResultSetFuture partitionsFuture = fetchPartitions(tenantId, entityId, query.getKey(), minPartition, maxPartition);
 
 
             final SimpleListenableFuture<Void> resultFuture = new SimpleListenableFuture<>();
             final SimpleListenableFuture<Void> resultFuture = new SimpleListenableFuture<>();
-            final ListenableFuture<List<Long>> partitionsListFuture = Futures.transform(partitionsFuture, getPartitionsArrayFunction(), readResultsProcessingExecutor);
+            final ListenableFuture<List<Long>> partitionsListFuture = Futures.transformAsync(partitionsFuture, getPartitionsArrayFunction(), readResultsProcessingExecutor);
 
 
             Futures.addCallback(partitionsListFuture, new FutureCallback<List<Long>>() {
             Futures.addCallback(partitionsListFuture, new FutureCallback<List<Long>>() {
                 @Override
                 @Override
@@ -617,15 +652,17 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
             resultFuture.set(null);
             resultFuture.set(null);
         } else {
         } else {
             PreparedStatement proto = getDeletePartitionStmt();
             PreparedStatement proto = getDeletePartitionStmt();
-            BoundStatement stmt = proto.bind();
-            stmt.setString(0, cursor.getEntityType());
-            stmt.setUUID(1, cursor.getEntityId());
-            stmt.setLong(2, cursor.getNextPartition());
-            stmt.setString(3, cursor.getKey());
+            BoundStatementBuilder stmtBuilder = new BoundStatementBuilder(proto.bind());
+            stmtBuilder.setString(0, cursor.getEntityType());
+            stmtBuilder.setUuid(1, cursor.getEntityId());
+            stmtBuilder.setLong(2, cursor.getNextPartition());
+            stmtBuilder.setString(3, cursor.getKey());
 
 
-            Futures.addCallback(executeAsyncWrite(tenantId, stmt), new FutureCallback<ResultSet>() {
+            BoundStatement stmt = stmtBuilder.build();
+
+            Futures.addCallback(executeAsyncWrite(tenantId, stmt), new FutureCallback<AsyncResultSet>() {
                 @Override
                 @Override
-                public void onSuccess(@Nullable ResultSet result) {
+                public void onSuccess(@Nullable AsyncResultSet result) {
                     deletePartitionAsync(tenantId, cursor, resultFuture);
                     deletePartitionAsync(tenantId, cursor, resultFuture);
                 }
                 }
 
 
@@ -648,6 +685,11 @@ 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) {
     private List<TsKvEntry> convertResultToTsKvEntryList(List<Row> rows) {
         List<TsKvEntry> entries = new ArrayList<>(rows.size());
         List<TsKvEntry> entries = new ArrayList<>(rows.size());
         if (!rows.isEmpty()) {
         if (!rows.isEmpty()) {
@@ -706,12 +748,14 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
      * Select existing partitions from the table
      * Select existing partitions from the table
      * <code>{@link ModelConstants#TS_KV_PARTITIONS_CF}</code> for the given entity
      * <code>{@link ModelConstants#TS_KV_PARTITIONS_CF}</code> for the given entity
      */
      */
-    private ResultSetFuture fetchPartitions(TenantId tenantId, EntityId entityId, String key, long minPartition, long maxPartition) {
-        Select.Where select = QueryBuilder.select(ModelConstants.PARTITION_COLUMN).from(ModelConstants.TS_KV_PARTITIONS_CF).where(eq(ModelConstants.ENTITY_TYPE_COLUMN, entityId.getEntityType().name()))
-                .and(eq(ModelConstants.ENTITY_ID_COLUMN, entityId.getId())).and(eq(ModelConstants.KEY_COLUMN, key));
-        select.and(QueryBuilder.gte(ModelConstants.PARTITION_COLUMN, minPartition));
-        select.and(QueryBuilder.lte(ModelConstants.PARTITION_COLUMN, maxPartition));
-        return executeAsyncRead(tenantId, select);
+    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) {
@@ -882,11 +926,11 @@ public class CassandraBaseTimeseriesDao extends CassandraAbstractAsyncDao implem
         }
         }
     }
     }
 
 
-    private static void addValue(KvEntry kvEntry, BoundStatement stmt, int column) {
+    private static void addValue(KvEntry kvEntry, BoundStatementBuilder stmt, int column) {
         switch (kvEntry.getDataType()) {
         switch (kvEntry.getDataType()) {
             case BOOLEAN:
             case BOOLEAN:
                 Optional<Boolean> booleanValue = kvEntry.getBooleanValue();
                 Optional<Boolean> booleanValue = kvEntry.getBooleanValue();
-                booleanValue.ifPresent(b -> stmt.setBool(column, b));
+                booleanValue.ifPresent(b -> stmt.setBoolean(column, b));
                 break;
                 break;
             case STRING:
             case STRING:
                 Optional<String> stringValue = kvEntry.getStrValue();
                 Optional<String> stringValue = kvEntry.getStrValue();

@@ -15,7 +15,14 @@
  */
  */
 package org.thingsboard.server.dao.util;
 package org.thingsboard.server.dao.util;
 
 
-import com.datastax.driver.core.*;
+import com.datastax.oss.driver.api.core.ProtocolVersion;
+import com.datastax.oss.driver.api.core.cql.BoundStatement;
+import com.datastax.oss.driver.api.core.cql.ColumnDefinition;
+import com.datastax.oss.driver.api.core.cql.ColumnDefinitions;
+import com.datastax.oss.driver.api.core.cql.PreparedStatement;
+import com.datastax.oss.driver.api.core.type.DataType;
+import com.datastax.oss.driver.api.core.type.codec.TypeCodec;
+import com.datastax.oss.driver.api.core.type.codec.registry.CodecRegistry;
 import com.google.common.util.concurrent.FutureCallback;
 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;
@@ -212,7 +219,7 @@ public abstract class AbstractBufferedRateExecutor<T extends AsyncTask, F extend
         CassandraStatementTask cassStmtTask = (CassandraStatementTask) taskCtx.getTask();
         CassandraStatementTask cassStmtTask = (CassandraStatementTask) taskCtx.getTask();
         if (cassStmtTask.getStatement() instanceof BoundStatement) {
         if (cassStmtTask.getStatement() instanceof BoundStatement) {
             BoundStatement stmt = (BoundStatement) cassStmtTask.getStatement();
             BoundStatement stmt = (BoundStatement) cassStmtTask.getStatement();
-            String query = stmt.preparedStatement().getQueryString();
+            String query = stmt.getPreparedStatement().getQuery();
             try {
             try {
                 query = toStringWithValues(stmt, ProtocolVersion.V5);
                 query = toStringWithValues(stmt, ProtocolVersion.V5);
             } catch (Exception e) {
             } catch (Exception e) {
@@ -225,16 +232,16 @@ public abstract class AbstractBufferedRateExecutor<T extends AsyncTask, F extend
     }
     }
 
 
     private static String toStringWithValues(BoundStatement boundStatement, ProtocolVersion protocolVersion) {
     private static String toStringWithValues(BoundStatement boundStatement, ProtocolVersion protocolVersion) {
-        CodecRegistry codecRegistry = boundStatement.preparedStatement().getCodecRegistry();
-        PreparedStatement preparedStatement = boundStatement.preparedStatement();
-        String query = preparedStatement.getQueryString();
-        ColumnDefinitions defs = preparedStatement.getVariables();
+        CodecRegistry codecRegistry = boundStatement.codecRegistry();
+        PreparedStatement preparedStatement = boundStatement.getPreparedStatement();
+        String query = preparedStatement.getQuery();
+        ColumnDefinitions defs = preparedStatement.getVariableDefinitions();
         int index = 0;
         int index = 0;
-        for (ColumnDefinitions.Definition def : defs) {
+        for (ColumnDefinition def : defs) {
             DataType type = def.getType();
             DataType type = def.getType();
             TypeCodec<Object> codec = codecRegistry.codecFor(type);
             TypeCodec<Object> codec = codecRegistry.codecFor(type);
             if (boundStatement.getBytesUnsafe(index) != null) {
             if (boundStatement.getBytesUnsafe(index) != null) {
-                Object value = codec.deserialize(boundStatement.getBytesUnsafe(index), protocolVersion);
+                Object value = codec.decode(boundStatement.getBytesUnsafe(index), protocolVersion);
                 String replacement = Matcher.quoteReplacement(codec.format(value));
                 String replacement = Matcher.quoteReplacement(codec.format(value));
                 query = query.replaceFirst("\\?", replacement);
                 query = query.replaceFirst("\\?", replacement);
             }
             }

@@ -15,8 +15,7 @@
  */
  */
 package org.thingsboard.server.dao;
 package org.thingsboard.server.dao;
 
 
-import com.datastax.driver.core.Cluster;
-import com.datastax.driver.core.Session;
+import com.datastax.oss.driver.api.core.CqlSession;
 import org.cassandraunit.BaseCassandraUnit;
 import org.cassandraunit.BaseCassandraUnit;
 import org.cassandraunit.CQLDataLoader;
 import org.cassandraunit.CQLDataLoader;
 import org.cassandraunit.dataset.CQLDataSet;
 import org.cassandraunit.dataset.CQLDataSet;
@@ -27,8 +26,7 @@ import java.util.List;
 public class CustomCassandraCQLUnit extends BaseCassandraUnit {
 public class CustomCassandraCQLUnit extends BaseCassandraUnit {
     protected List<CQLDataSet> dataSets;
     protected List<CQLDataSet> dataSets;
 
 
-    public Session session;
-    public Cluster cluster;
+    public CqlSession session;
 
 
     public CustomCassandraCQLUnit(List<CQLDataSet> dataSets) {
     public CustomCassandraCQLUnit(List<CQLDataSet> dataSets) {
         this.dataSets = dataSets;
         this.dataSets = dataSets;
@@ -65,11 +63,7 @@ public class CustomCassandraCQLUnit extends BaseCassandraUnit {
 
 
     @Override
     @Override
     protected void load() {
     protected void load() {
-        String hostIp = EmbeddedCassandraServerHelper.getHost();
-        int port = EmbeddedCassandraServerHelper.getNativeTransportPort();
-        cluster = new Cluster.Builder().addContactPoints(hostIp).withPort(port).withSocketOptions(getSocketOptions())
-                .build();
-        session = cluster.connect();
+        session = EmbeddedCassandraServerHelper.getSession();
         CQLDataLoader dataLoader = new CQLDataLoader(session);
         CQLDataLoader dataLoader = new CQLDataLoader(session);
         dataSets.forEach(dataLoader::load);
         dataSets.forEach(dataLoader::load);
         session = dataLoader.getSession();
         session = dataLoader.getSession();
@@ -79,20 +73,16 @@ public class CustomCassandraCQLUnit extends BaseCassandraUnit {
     @Override
     @Override
     protected void after() {
     protected void after() {
         super.after();
         super.after();
-        try (Cluster c = cluster; Session s = session) {
+        try (CqlSession s = session) {
             session = null;
             session = null;
-            cluster = null;
         }
         }
         System.setSecurityManager(null);
         System.setSecurityManager(null);
     }
     }
 
 
     // Getters for those who do not like to directly access fields
     // Getters for those who do not like to directly access fields
 
 
-    public Session getSession() {
+    public CqlSession getSession() {
         return session;
         return session;
     }
     }
 
 
-    public Cluster getCluster() {
-        return cluster;
-    }
 }
 }

@@ -32,7 +32,7 @@ public class NoSqlDaoServiceTestSuite {
     @ClassRule
     @ClassRule
     public static CustomSqlUnit sqlUnit = new CustomSqlUnit(
     public static CustomSqlUnit sqlUnit = new CustomSqlUnit(
             Arrays.asList("sql/schema-entities-hsql.sql", "sql/schema-entities-idx.sql", "sql/system-data.sql", "sql/system-test.sql"),
             Arrays.asList("sql/schema-entities-hsql.sql", "sql/schema-entities-idx.sql", "sql/system-data.sql", "sql/system-test.sql"),
-            "sql/drop-all-tables.sql",
+            "sql/hsql/drop-all-tables.sql",
             "nosql-test.properties"
             "nosql-test.properties"
     );
     );
 
 

-/**
- * 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.nosql;
-
-import com.datastax.driver.core.ProtocolVersion;
-import com.datastax.driver.core.ResultSet;
-import com.datastax.driver.core.ResultSetFuture;
-import com.datastax.driver.core.Row;
-import com.datastax.driver.core.Session;
-import com.datastax.driver.core.Statement;
-import com.datastax.driver.core.exceptions.UnsupportedFeatureException;
-import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.MoreExecutors;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
-import org.mockito.stubbing.Answer;
-import org.thingsboard.server.dao.exception.BufferLimitException;
-import org.thingsboard.server.dao.util.AsyncRateLimiter;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeoutException;
-
-import static org.junit.Assert.assertSame;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
-
-@RunWith(MockitoJUnitRunner.class)
-public class RateLimitedResultSetFutureTest {
-
-    private RateLimitedResultSetFuture resultSetFuture;
-
-    @Mock
-    private AsyncRateLimiter rateLimiter;
-    @Mock
-    private Session session;
-    @Mock
-    private Statement statement;
-    @Mock
-    private ResultSetFuture realFuture;
-    @Mock
-    private ResultSet rows;
-    @Mock
-    private Row row;
-
-    @Test
-    public void doNotReleasePermissionIfRateLimitFutureFailed() throws InterruptedException {
-        when(rateLimiter.acquireAsync()).thenReturn(Futures.immediateFailedFuture(new BufferLimitException()));
-        resultSetFuture = new RateLimitedResultSetFuture(session, rateLimiter, statement);
-        Thread.sleep(1000L);
-        verify(rateLimiter).acquireAsync();
-        try {
-            assertTrue(resultSetFuture.isDone());
-            fail();
-        } catch (Exception e) {
-            assertTrue(e instanceof IllegalStateException);
-            Throwable actualCause = e.getCause();
-            assertTrue(actualCause instanceof ExecutionException);
-        }
-        verifyNoMoreInteractions(session, rateLimiter, statement);
-
-    }
-
-    @Test
-    public void getUninterruptiblyDelegateToCassandra() throws InterruptedException, ExecutionException {
-        when(rateLimiter.acquireAsync()).thenReturn(Futures.immediateFuture(null));
-        when(session.executeAsync(statement)).thenReturn(realFuture);
-        Mockito.doAnswer((Answer<Void>) invocation -> {
-            Object[] args = invocation.getArguments();
-            Runnable task = (Runnable) args[0];
-            task.run();
-            return null;
-        }).when(realFuture).addListener(Mockito.any(), Mockito.any());
-
-        when(realFuture.getUninterruptibly()).thenReturn(rows);
-
-        resultSetFuture = new RateLimitedResultSetFuture(session, rateLimiter, statement);
-        ResultSet actual = resultSetFuture.getUninterruptibly();
-        assertSame(rows, actual);
-        verify(rateLimiter, times(1)).acquireAsync();
-        verify(rateLimiter, times(1)).release();
-    }
-
-    @Test
-    public void addListenerAllowsFutureTransformation() throws InterruptedException, ExecutionException {
-        when(rateLimiter.acquireAsync()).thenReturn(Futures.immediateFuture(null));
-        when(session.executeAsync(statement)).thenReturn(realFuture);
-        Mockito.doAnswer((Answer<Void>) invocation -> {
-            Object[] args = invocation.getArguments();
-            Runnable task = (Runnable) args[0];
-            task.run();
-            return null;
-        }).when(realFuture).addListener(Mockito.any(), Mockito.any());
-
-        when(realFuture.get()).thenReturn(rows);
-        when(rows.one()).thenReturn(row);
-
-        resultSetFuture = new RateLimitedResultSetFuture(session, rateLimiter, statement);
-
-        ListenableFuture<Row> transform = Futures.transform(resultSetFuture, ResultSet::one, MoreExecutors.directExecutor());
-        Row actualRow = transform.get();
-
-        assertSame(row, actualRow);
-        verify(rateLimiter, times(1)).acquireAsync();
-        verify(rateLimiter, times(1)).release();
-    }
-
-    @Test
-    public void immidiateCassandraExceptionReturnsPermit() throws InterruptedException, ExecutionException {
-        when(rateLimiter.acquireAsync()).thenReturn(Futures.immediateFuture(null));
-        when(session.executeAsync(statement)).thenThrow(new UnsupportedFeatureException(ProtocolVersion.V3, "hjg"));
-        resultSetFuture = new RateLimitedResultSetFuture(session, rateLimiter, statement);
-        ListenableFuture<Row> transform = Futures.transform(resultSetFuture, ResultSet::one, MoreExecutors.directExecutor());
-        try {
-            transform.get();
-            fail();
-        } catch (Exception e) {
-            assertTrue(e instanceof ExecutionException);
-        }
-        verify(rateLimiter, times(1)).acquireAsync();
-        verify(rateLimiter, times(1)).release();
-    }
-
-    @Test
-    public void queryTimeoutReturnsPermit() throws InterruptedException, ExecutionException {
-        when(rateLimiter.acquireAsync()).thenReturn(Futures.immediateFuture(null));
-        when(session.executeAsync(statement)).thenReturn(realFuture);
-        Mockito.doAnswer((Answer<Void>) invocation -> {
-            Object[] args = invocation.getArguments();
-            Runnable task = (Runnable) args[0];
-            task.run();
-            return null;
-        }).when(realFuture).addListener(Mockito.any(), Mockito.any());
-
-        when(realFuture.get()).thenThrow(new ExecutionException("Fail", new TimeoutException("timeout")));
-        resultSetFuture = new RateLimitedResultSetFuture(session, rateLimiter, statement);
-        ListenableFuture<Row> transform = Futures.transform(resultSetFuture, ResultSet::one, MoreExecutors.directExecutor());
-        try {
-            transform.get();
-            fail();
-        } catch (Exception e) {
-            assertTrue(e instanceof ExecutionException);
-        }
-        verify(rateLimiter, times(1)).acquireAsync();
-        verify(rateLimiter, times(1)).release();
-    }
-
-    @Test
-    public void expiredQueryReturnPermit() throws InterruptedException, ExecutionException {
-        CountDownLatch latch = new CountDownLatch(1);
-        ListenableFuture<Void> future = MoreExecutors.listeningDecorator(Executors.newFixedThreadPool(1)).submit(() -> {
-            latch.await();
-            return null;
-        });
-        when(rateLimiter.acquireAsync()).thenReturn(future);
-        resultSetFuture = new RateLimitedResultSetFuture(session, rateLimiter, statement);
-
-        ListenableFuture<Row> transform = Futures.transform(resultSetFuture, ResultSet::one, MoreExecutors.directExecutor());
-//        TimeUnit.MILLISECONDS.sleep(200);
-        future.cancel(false);
-        latch.countDown();
-
-        try {
-            transform.get();
-            fail();
-        } catch (Exception e) {
-            assertTrue(e instanceof ExecutionException);
-        }
-        verify(rateLimiter, times(1)).acquireAsync();
-        verify(rateLimiter, times(1)).release();
-    }
-
-}

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.service;
 package org.thingsboard.server.dao.service;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.junit.runner.RunWith;
 import org.junit.runner.RunWith;
@@ -134,7 +134,7 @@ public abstract class AbstractServiceTest {
 
 
     protected Event generateEvent(TenantId tenantId, EntityId entityId, String eventType, String eventUid) throws IOException {
     protected Event generateEvent(TenantId tenantId, EntityId entityId, String eventType, String eventUid) throws IOException {
         if (tenantId == null) {
         if (tenantId == null) {
-            tenantId = new TenantId(UUIDs.timeBased());
+            tenantId = new TenantId(Uuids.timeBased());
         }
         }
         Event event = new Event();
         Event event = new Event();
         event.setTenantId(tenantId);
         event.setTenantId(tenantId);

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.service;
 package org.thingsboard.server.dao.service;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.junit.After;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Before;
@@ -59,8 +59,8 @@ public abstract class BaseAlarmServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void testSaveAndFetchAlarm() throws ExecutionException, InterruptedException {
     public void testSaveAndFetchAlarm() throws ExecutionException, InterruptedException {
-        AssetId parentId = new AssetId(UUIDs.timeBased());
-        AssetId childId = new AssetId(UUIDs.timeBased());
+        AssetId parentId = new AssetId(Uuids.timeBased());
+        AssetId childId = new AssetId(Uuids.timeBased());
 
 
         EntityRelation relation = new EntityRelation(parentId, childId, EntityRelation.CONTAINS_TYPE);
         EntityRelation relation = new EntityRelation(parentId, childId, EntityRelation.CONTAINS_TYPE);
 
 
@@ -96,8 +96,8 @@ public abstract class BaseAlarmServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void testFindAlarm() throws ExecutionException, InterruptedException {
     public void testFindAlarm() throws ExecutionException, InterruptedException {
-        AssetId parentId = new AssetId(UUIDs.timeBased());
-        AssetId childId = new AssetId(UUIDs.timeBased());
+        AssetId parentId = new AssetId(Uuids.timeBased());
+        AssetId childId = new AssetId(Uuids.timeBased());
 
 
         EntityRelation relation = new EntityRelation(parentId, childId, EntityRelation.CONTAINS_TYPE);
         EntityRelation relation = new EntityRelation(parentId, childId, EntityRelation.CONTAINS_TYPE);
 
 
@@ -197,8 +197,8 @@ public abstract class BaseAlarmServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void testDeleteAlarm() throws ExecutionException, InterruptedException {
     public void testDeleteAlarm() throws ExecutionException, InterruptedException {
-        AssetId parentId = new AssetId(UUIDs.timeBased());
-        AssetId childId = new AssetId(UUIDs.timeBased());
+        AssetId parentId = new AssetId(Uuids.timeBased());
+        AssetId childId = new AssetId(Uuids.timeBased());
 
 
         EntityRelation relation = new EntityRelation(parentId, childId, EntityRelation.CONTAINS_TYPE);
         EntityRelation relation = new EntityRelation(parentId, childId, EntityRelation.CONTAINS_TYPE);
 
 

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.service;
 package org.thingsboard.server.dao.service;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.junit.After;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Assert;
@@ -104,7 +104,7 @@ public abstract class BaseAssetServiceTest extends AbstractServiceTest {
         Asset asset = new Asset();
         Asset asset = new Asset();
         asset.setName("My asset");
         asset.setName("My asset");
         asset.setType("default");
         asset.setType("default");
-        asset.setTenantId(new TenantId(UUIDs.timeBased()));
+        asset.setTenantId(new TenantId(Uuids.timeBased()));
         assetService.saveAsset(asset);
         assetService.saveAsset(asset);
     }
     }
 
 
@@ -116,7 +116,7 @@ public abstract class BaseAssetServiceTest extends AbstractServiceTest {
         asset.setTenantId(tenantId);
         asset.setTenantId(tenantId);
         asset = assetService.saveAsset(asset);
         asset = assetService.saveAsset(asset);
         try {
         try {
-            assetService.assignAssetToCustomer(tenantId, asset.getId(), new CustomerId(UUIDs.timeBased()));
+            assetService.assignAssetToCustomer(tenantId, asset.getId(), new CustomerId(Uuids.timeBased()));
         } finally {
         } finally {
             assetService.deleteAsset(tenantId, asset.getId());
             assetService.deleteAsset(tenantId, asset.getId());
         }
         }

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.service;
 package org.thingsboard.server.dao.service;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.junit.After;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Assert;
@@ -105,7 +105,7 @@ public abstract class BaseCustomerServiceTest extends AbstractServiceTest {
     public void testSaveCustomerWithInvalidTenant() {
     public void testSaveCustomerWithInvalidTenant() {
         Customer customer = new Customer();
         Customer customer = new Customer();
         customer.setTitle("My customer");
         customer.setTitle("My customer");
-        customer.setTenantId(new TenantId(UUIDs.timeBased()));
+        customer.setTenantId(new TenantId(Uuids.timeBased()));
         customerService.saveCustomer(customer);
         customerService.saveCustomer(customer);
     }
     }
 
 

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.service;
 package org.thingsboard.server.dao.service;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.junit.After;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Assert;
@@ -98,7 +98,7 @@ public abstract class BaseDashboardServiceTest extends AbstractServiceTest {
     public void testSaveDashboardWithInvalidTenant() {
     public void testSaveDashboardWithInvalidTenant() {
         Dashboard dashboard = new Dashboard();
         Dashboard dashboard = new Dashboard();
         dashboard.setTitle("My dashboard");
         dashboard.setTitle("My dashboard");
-        dashboard.setTenantId(new TenantId(UUIDs.timeBased()));
+        dashboard.setTenantId(new TenantId(Uuids.timeBased()));
         dashboardService.saveDashboard(dashboard);
         dashboardService.saveDashboard(dashboard);
     }
     }
     
     
@@ -109,7 +109,7 @@ public abstract class BaseDashboardServiceTest extends AbstractServiceTest {
         dashboard.setTenantId(tenantId);
         dashboard.setTenantId(tenantId);
         dashboard = dashboardService.saveDashboard(dashboard);
         dashboard = dashboardService.saveDashboard(dashboard);
         try {
         try {
-            dashboardService.assignDashboardToCustomer(tenantId, dashboard.getId(), new CustomerId(UUIDs.timeBased()));
+            dashboardService.assignDashboardToCustomer(tenantId, dashboard.getId(), new CustomerId(Uuids.timeBased()));
         } finally {
         } finally {
             dashboardService.deleteDashboard(tenantId, dashboard.getId());
             dashboardService.deleteDashboard(tenantId, dashboard.getId());
         }
         }

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.service;
 package org.thingsboard.server.dao.service;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.junit.After;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Before;
@@ -109,7 +109,7 @@ public abstract class BaseDeviceCredentialsServiceTest extends AbstractServiceTe
         device.setTenantId(tenantId);
         device.setTenantId(tenantId);
         device = deviceService.saveDevice(device);
         device = deviceService.saveDevice(device);
         DeviceCredentials deviceCredentials = deviceCredentialsService.findDeviceCredentialsByDeviceId(tenantId, device.getId());
         DeviceCredentials deviceCredentials = deviceCredentialsService.findDeviceCredentialsByDeviceId(tenantId, device.getId());
-        DeviceCredentials newDeviceCredentials = new DeviceCredentials(new DeviceCredentialsId(UUIDs.timeBased()));
+        DeviceCredentials newDeviceCredentials = new DeviceCredentials(new DeviceCredentialsId(Uuids.timeBased()));
         newDeviceCredentials.setCreatedTime(deviceCredentials.getCreatedTime());
         newDeviceCredentials.setCreatedTime(deviceCredentials.getCreatedTime());
         newDeviceCredentials.setDeviceId(deviceCredentials.getDeviceId());
         newDeviceCredentials.setDeviceId(deviceCredentials.getDeviceId());
         newDeviceCredentials.setCredentialsType(deviceCredentials.getCredentialsType());
         newDeviceCredentials.setCredentialsType(deviceCredentials.getCredentialsType());
@@ -129,7 +129,7 @@ public abstract class BaseDeviceCredentialsServiceTest extends AbstractServiceTe
         device.setTenantId(tenantId);
         device.setTenantId(tenantId);
         device = deviceService.saveDevice(device);
         device = deviceService.saveDevice(device);
         DeviceCredentials deviceCredentials = deviceCredentialsService.findDeviceCredentialsByDeviceId(tenantId, device.getId());
         DeviceCredentials deviceCredentials = deviceCredentialsService.findDeviceCredentialsByDeviceId(tenantId, device.getId());
-        deviceCredentials.setDeviceId(new DeviceId(UUIDs.timeBased()));
+        deviceCredentials.setDeviceId(new DeviceId(Uuids.timeBased()));
         try {
         try {
             deviceCredentialsService.updateDeviceCredentials(tenantId, deviceCredentials);
             deviceCredentialsService.updateDeviceCredentials(tenantId, deviceCredentials);
         } finally {
         } finally {

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.service;
 package org.thingsboard.server.dao.service;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.junit.After;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Assert;
@@ -110,7 +110,7 @@ public abstract class BaseDeviceServiceTest extends AbstractServiceTest {
         Device device = new Device();
         Device device = new Device();
         device.setName("My device");
         device.setName("My device");
         device.setType("default");
         device.setType("default");
-        device.setTenantId(new TenantId(UUIDs.timeBased()));
+        device.setTenantId(new TenantId(Uuids.timeBased()));
         deviceService.saveDevice(device);
         deviceService.saveDevice(device);
     }
     }
     
     
@@ -122,7 +122,7 @@ public abstract class BaseDeviceServiceTest extends AbstractServiceTest {
         device.setTenantId(tenantId);
         device.setTenantId(tenantId);
         device = deviceService.saveDevice(device);
         device = deviceService.saveDevice(device);
         try {
         try {
-            deviceService.assignDeviceToCustomer(tenantId, device.getId(), new CustomerId(UUIDs.timeBased()));
+            deviceService.assignDeviceToCustomer(tenantId, device.getId(), new CustomerId(Uuids.timeBased()));
         } finally {
         } finally {
             deviceService.deleteDevice(tenantId, device.getId());
             deviceService.deleteDevice(tenantId, device.getId());
         }
         }

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.service;
 package org.thingsboard.server.dao.service;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.junit.After;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Before;
@@ -47,8 +47,8 @@ public abstract class BaseRelationServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void testSaveRelation() throws ExecutionException, InterruptedException {
     public void testSaveRelation() throws ExecutionException, InterruptedException {
-        AssetId parentId = new AssetId(UUIDs.timeBased());
-        AssetId childId = new AssetId(UUIDs.timeBased());
+        AssetId parentId = new AssetId(Uuids.timeBased());
+        AssetId childId = new AssetId(Uuids.timeBased());
 
 
         EntityRelation relation = new EntityRelation(parentId, childId, EntityRelation.CONTAINS_TYPE);
         EntityRelation relation = new EntityRelation(parentId, childId, EntityRelation.CONTAINS_TYPE);
 
 
@@ -65,9 +65,9 @@ public abstract class BaseRelationServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void testDeleteRelation() throws ExecutionException, InterruptedException {
     public void testDeleteRelation() throws ExecutionException, InterruptedException {
-        AssetId parentId = new AssetId(UUIDs.timeBased());
-        AssetId childId = new AssetId(UUIDs.timeBased());
-        AssetId subChildId = new AssetId(UUIDs.timeBased());
+        AssetId parentId = new AssetId(Uuids.timeBased());
+        AssetId childId = new AssetId(Uuids.timeBased());
+        AssetId subChildId = new AssetId(Uuids.timeBased());
 
 
         EntityRelation relationA = new EntityRelation(parentId, childId, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationA = new EntityRelation(parentId, childId, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationB = new EntityRelation(childId, subChildId, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationB = new EntityRelation(childId, subChildId, EntityRelation.CONTAINS_TYPE);
@@ -86,9 +86,9 @@ public abstract class BaseRelationServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void testDeleteEntityRelations() throws ExecutionException, InterruptedException {
     public void testDeleteEntityRelations() throws ExecutionException, InterruptedException {
-        AssetId parentId = new AssetId(UUIDs.timeBased());
-        AssetId childId = new AssetId(UUIDs.timeBased());
-        AssetId subChildId = new AssetId(UUIDs.timeBased());
+        AssetId parentId = new AssetId(Uuids.timeBased());
+        AssetId childId = new AssetId(Uuids.timeBased());
+        AssetId subChildId = new AssetId(Uuids.timeBased());
 
 
         EntityRelation relationA = new EntityRelation(parentId, childId, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationA = new EntityRelation(parentId, childId, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationB = new EntityRelation(childId, subChildId, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationB = new EntityRelation(childId, subChildId, EntityRelation.CONTAINS_TYPE);
@@ -105,10 +105,10 @@ public abstract class BaseRelationServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void testFindFrom() throws ExecutionException, InterruptedException {
     public void testFindFrom() throws ExecutionException, InterruptedException {
-        AssetId parentA = new AssetId(UUIDs.timeBased());
-        AssetId parentB = new AssetId(UUIDs.timeBased());
-        AssetId childA = new AssetId(UUIDs.timeBased());
-        AssetId childB = new AssetId(UUIDs.timeBased());
+        AssetId parentA = new AssetId(Uuids.timeBased());
+        AssetId parentB = new AssetId(Uuids.timeBased());
+        AssetId childA = new AssetId(Uuids.timeBased());
+        AssetId childB = new AssetId(Uuids.timeBased());
 
 
         EntityRelation relationA1 = new EntityRelation(parentA, childA, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationA1 = new EntityRelation(parentA, childA, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationA2 = new EntityRelation(parentA, childB, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationA2 = new EntityRelation(parentA, childB, EntityRelation.CONTAINS_TYPE);
@@ -157,10 +157,10 @@ public abstract class BaseRelationServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void testFindTo() throws ExecutionException, InterruptedException {
     public void testFindTo() throws ExecutionException, InterruptedException {
-        AssetId parentA = new AssetId(UUIDs.timeBased());
-        AssetId parentB = new AssetId(UUIDs.timeBased());
-        AssetId childA = new AssetId(UUIDs.timeBased());
-        AssetId childB = new AssetId(UUIDs.timeBased());
+        AssetId parentA = new AssetId(Uuids.timeBased());
+        AssetId parentB = new AssetId(Uuids.timeBased());
+        AssetId childA = new AssetId(Uuids.timeBased());
+        AssetId childB = new AssetId(Uuids.timeBased());
 
 
         EntityRelation relationA1 = new EntityRelation(parentA, childA, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationA1 = new EntityRelation(parentA, childA, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationA2 = new EntityRelation(parentA, childB, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationA2 = new EntityRelation(parentA, childB, EntityRelation.CONTAINS_TYPE);
@@ -207,9 +207,9 @@ public abstract class BaseRelationServiceTest extends AbstractServiceTest {
     @Test
     @Test
     public void testCyclicRecursiveRelation() throws ExecutionException, InterruptedException {
     public void testCyclicRecursiveRelation() throws ExecutionException, InterruptedException {
         // A -> B -> C -> A
         // A -> B -> C -> A
-        AssetId assetA = new AssetId(UUIDs.timeBased());
-        AssetId assetB = new AssetId(UUIDs.timeBased());
-        AssetId assetC = new AssetId(UUIDs.timeBased());
+        AssetId assetA = new AssetId(Uuids.timeBased());
+        AssetId assetB = new AssetId(Uuids.timeBased());
+        AssetId assetC = new AssetId(Uuids.timeBased());
 
 
         EntityRelation relationA = new EntityRelation(assetA, assetB, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationA = new EntityRelation(assetA, assetB, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationB = new EntityRelation(assetB, assetC, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationB = new EntityRelation(assetB, assetC, EntityRelation.CONTAINS_TYPE);
@@ -239,10 +239,10 @@ public abstract class BaseRelationServiceTest extends AbstractServiceTest {
     @Test
     @Test
     public void testRecursiveRelation() throws ExecutionException, InterruptedException {
     public void testRecursiveRelation() throws ExecutionException, InterruptedException {
         // A -> B -> [C,D]
         // A -> B -> [C,D]
-        AssetId assetA = new AssetId(UUIDs.timeBased());
-        AssetId assetB = new AssetId(UUIDs.timeBased());
-        AssetId assetC = new AssetId(UUIDs.timeBased());
-        DeviceId deviceD = new DeviceId(UUIDs.timeBased());
+        AssetId assetA = new AssetId(Uuids.timeBased());
+        AssetId assetB = new AssetId(Uuids.timeBased());
+        AssetId assetC = new AssetId(Uuids.timeBased());
+        DeviceId deviceD = new DeviceId(Uuids.timeBased());
 
 
         EntityRelation relationAB = new EntityRelation(assetA, assetB, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationAB = new EntityRelation(assetA, assetB, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationBC = new EntityRelation(assetB, assetC, EntityRelation.CONTAINS_TYPE);
         EntityRelation relationBC = new EntityRelation(assetB, assetC, EntityRelation.CONTAINS_TYPE);
@@ -272,7 +272,7 @@ public abstract class BaseRelationServiceTest extends AbstractServiceTest {
     @Test(expected = DataValidationException.class)
     @Test(expected = DataValidationException.class)
     public void testSaveRelationWithEmptyFrom() throws ExecutionException, InterruptedException {
     public void testSaveRelationWithEmptyFrom() throws ExecutionException, InterruptedException {
         EntityRelation relation = new EntityRelation();
         EntityRelation relation = new EntityRelation();
-        relation.setTo(new AssetId(UUIDs.timeBased()));
+        relation.setTo(new AssetId(Uuids.timeBased()));
         relation.setType(EntityRelation.CONTAINS_TYPE);
         relation.setType(EntityRelation.CONTAINS_TYPE);
         Assert.assertTrue(saveRelation(relation));
         Assert.assertTrue(saveRelation(relation));
     }
     }
@@ -280,7 +280,7 @@ public abstract class BaseRelationServiceTest extends AbstractServiceTest {
     @Test(expected = DataValidationException.class)
     @Test(expected = DataValidationException.class)
     public void testSaveRelationWithEmptyTo() throws ExecutionException, InterruptedException {
     public void testSaveRelationWithEmptyTo() throws ExecutionException, InterruptedException {
         EntityRelation relation = new EntityRelation();
         EntityRelation relation = new EntityRelation();
-        relation.setFrom(new AssetId(UUIDs.timeBased()));
+        relation.setFrom(new AssetId(Uuids.timeBased()));
         relation.setType(EntityRelation.CONTAINS_TYPE);
         relation.setType(EntityRelation.CONTAINS_TYPE);
         Assert.assertTrue(saveRelation(relation));
         Assert.assertTrue(saveRelation(relation));
     }
     }
@@ -288,8 +288,8 @@ public abstract class BaseRelationServiceTest extends AbstractServiceTest {
     @Test(expected = DataValidationException.class)
     @Test(expected = DataValidationException.class)
     public void testSaveRelationWithEmptyType() throws ExecutionException, InterruptedException {
     public void testSaveRelationWithEmptyType() throws ExecutionException, InterruptedException {
         EntityRelation relation = new EntityRelation();
         EntityRelation relation = new EntityRelation();
-        relation.setFrom(new AssetId(UUIDs.timeBased()));
-        relation.setTo(new AssetId(UUIDs.timeBased()));
+        relation.setFrom(new AssetId(Uuids.timeBased()));
+        relation.setTo(new AssetId(Uuids.timeBased()));
         Assert.assertTrue(saveRelation(relation));
         Assert.assertTrue(saveRelation(relation));
     }
     }
 }
 }

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.service;
 package org.thingsboard.server.dao.service;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.apache.commons.lang3.RandomStringUtils;
 import org.junit.After;
 import org.junit.After;
@@ -94,7 +94,7 @@ public abstract class BaseRuleChainServiceTest extends AbstractServiceTest {
     public void testSaveRuleChainWithInvalidTenant() {
     public void testSaveRuleChainWithInvalidTenant() {
         RuleChain ruleChain = new RuleChain();
         RuleChain ruleChain = new RuleChain();
         ruleChain.setName("My RuleChain");
         ruleChain.setName("My RuleChain");
-        ruleChain.setTenantId(new TenantId(UUIDs.timeBased()));
+        ruleChain.setTenantId(new TenantId(Uuids.timeBased()));
         ruleChainService.saveRuleChain(ruleChain);
         ruleChainService.saveRuleChain(ruleChain);
     }
     }
 
 

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.service;
 package org.thingsboard.server.dao.service;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import org.junit.After;
 import org.junit.After;
@@ -141,7 +141,7 @@ public abstract class BaseWidgetTypeServiceTest extends AbstractServiceTest {
         WidgetsBundle savedWidgetsBundle = widgetsBundleService.saveWidgetsBundle(widgetsBundle);
         WidgetsBundle savedWidgetsBundle = widgetsBundleService.saveWidgetsBundle(widgetsBundle);
 
 
         WidgetType widgetType = new WidgetType();
         WidgetType widgetType = new WidgetType();
-        widgetType.setTenantId(new TenantId(UUIDs.timeBased()));
+        widgetType.setTenantId(new TenantId(Uuids.timeBased()));
         widgetType.setBundleAlias(savedWidgetsBundle.getAlias());
         widgetType.setBundleAlias(savedWidgetsBundle.getAlias());
         widgetType.setName("Widget Type");
         widgetType.setName("Widget Type");
         widgetType.setDescriptor(new ObjectMapper().readValue("{ \"someKey\": \"someValue\" }", JsonNode.class));
         widgetType.setDescriptor(new ObjectMapper().readValue("{ \"someKey\": \"someValue\" }", JsonNode.class));

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.service;
 package org.thingsboard.server.dao.service;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.junit.After;
 import org.junit.After;
 import org.junit.Assert;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Before;
@@ -88,7 +88,7 @@ public abstract class BaseWidgetsBundleServiceTest extends AbstractServiceTest {
     public void testSaveWidgetsBundleWithInvalidTenant() {
     public void testSaveWidgetsBundleWithInvalidTenant() {
         WidgetsBundle widgetsBundle = new WidgetsBundle();
         WidgetsBundle widgetsBundle = new WidgetsBundle();
         widgetsBundle.setTitle("My widgets bundle");
         widgetsBundle.setTitle("My widgets bundle");
-        widgetsBundle.setTenantId(new TenantId(UUIDs.timeBased()));
+        widgetsBundle.setTenantId(new TenantId(Uuids.timeBased()));
         widgetsBundleService.saveWidgetsBundle(widgetsBundle);
         widgetsBundleService.saveWidgetsBundle(widgetsBundle);
     }
     }
 
 

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.service.attributes;
 package org.thingsboard.server.dao.service.attributes;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.junit.Assert;
 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.Test;
@@ -47,7 +47,7 @@ public abstract class BaseAttributesServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void saveAndFetch() throws Exception {
     public void saveAndFetch() throws Exception {
-        DeviceId deviceId = new DeviceId(UUIDs.timeBased());
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
         KvEntry attrValue = new StringDataEntry("attribute1", "value1");
         KvEntry attrValue = new StringDataEntry("attribute1", "value1");
         AttributeKvEntry attr = new BaseAttributeKvEntry(attrValue, 42L);
         AttributeKvEntry attr = new BaseAttributeKvEntry(attrValue, 42L);
         attributesService.save(SYSTEM_TENANT_ID, deviceId, DataConstants.CLIENT_SCOPE, Collections.singletonList(attr)).get();
         attributesService.save(SYSTEM_TENANT_ID, deviceId, DataConstants.CLIENT_SCOPE, Collections.singletonList(attr)).get();
@@ -58,7 +58,7 @@ public abstract class BaseAttributesServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void saveMultipleTypeAndFetch() throws Exception {
     public void saveMultipleTypeAndFetch() throws Exception {
-        DeviceId deviceId = new DeviceId(UUIDs.timeBased());
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
         KvEntry attrOldValue = new StringDataEntry("attribute1", "value1");
         KvEntry attrOldValue = new StringDataEntry("attribute1", "value1");
         AttributeKvEntry attrOld = new BaseAttributeKvEntry(attrOldValue, 42L);
         AttributeKvEntry attrOld = new BaseAttributeKvEntry(attrOldValue, 42L);
 
 
@@ -78,7 +78,7 @@ public abstract class BaseAttributesServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void findAll() throws Exception {
     public void findAll() throws Exception {
-        DeviceId deviceId = new DeviceId(UUIDs.timeBased());
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
 
 
         KvEntry attrAOldValue = new StringDataEntry("A", "value1");
         KvEntry attrAOldValue = new StringDataEntry("A", "value1");
         AttributeKvEntry attrAOld = new BaseAttributeKvEntry(attrAOldValue, 42L);
         AttributeKvEntry attrAOld = new BaseAttributeKvEntry(attrAOldValue, 42L);

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.service.event;
 package org.thingsboard.server.dao.service.event;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import org.junit.Assert;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.Test;
 import org.thingsboard.server.common.data.DataConstants;
 import org.thingsboard.server.common.data.DataConstants;
@@ -40,8 +40,8 @@ public abstract class BaseEventServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void saveEvent() throws Exception {
     public void saveEvent() throws Exception {
-        DeviceId devId = new DeviceId(UUIDs.timeBased());
-        Event event = generateEvent(null, devId, "ALARM", UUIDs.timeBased().toString());
+        DeviceId devId = new DeviceId(Uuids.timeBased());
+        Event event = generateEvent(null, devId, "ALARM", Uuids.timeBased().toString());
         Event saved = eventService.save(event);
         Event saved = eventService.save(event);
         Optional<Event> loaded = eventService.findEvent(event.getTenantId(), event.getEntityId(), event.getType(), event.getUid());
         Optional<Event> loaded = eventService.findEvent(event.getTenantId(), event.getEntityId(), event.getType(), event.getUid());
         Assert.assertTrue(loaded.isPresent());
         Assert.assertTrue(loaded.isPresent());
@@ -51,8 +51,8 @@ public abstract class BaseEventServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void saveEventIfNotExists() throws Exception {
     public void saveEventIfNotExists() throws Exception {
-        DeviceId devId = new DeviceId(UUIDs.timeBased());
-        Event event = generateEvent(null, devId, "ALARM", UUIDs.timeBased().toString());
+        DeviceId devId = new DeviceId(Uuids.timeBased());
+        Event event = generateEvent(null, devId, "ALARM", Uuids.timeBased().toString());
         Optional<Event> saved = eventService.saveIfNotExists(event);
         Optional<Event> saved = eventService.saveIfNotExists(event);
         Assert.assertTrue(saved.isPresent());
         Assert.assertTrue(saved.isPresent());
         saved = eventService.saveIfNotExists(event);
         saved = eventService.saveIfNotExists(event);
@@ -67,8 +67,8 @@ public abstract class BaseEventServiceTest extends AbstractServiceTest {
         long endTime = LocalDateTime.of(2016, Month.NOVEMBER, 1, 13, 0).toEpochSecond(ZoneOffset.UTC);
         long endTime = LocalDateTime.of(2016, Month.NOVEMBER, 1, 13, 0).toEpochSecond(ZoneOffset.UTC);
         long timeAfterEndTime = LocalDateTime.of(2016, Month.NOVEMBER, 1, 13, 30).toEpochSecond(ZoneOffset.UTC);
         long timeAfterEndTime = LocalDateTime.of(2016, Month.NOVEMBER, 1, 13, 30).toEpochSecond(ZoneOffset.UTC);
 
 
-        CustomerId customerId = new CustomerId(UUIDs.timeBased());
-        TenantId tenantId = new TenantId(UUIDs.timeBased());
+        CustomerId customerId = new CustomerId(Uuids.timeBased());
+        TenantId tenantId = new TenantId(Uuids.timeBased());
         saveEventWithProvidedTime(timeBeforeStartTime, customerId, tenantId);
         saveEventWithProvidedTime(timeBeforeStartTime, customerId, tenantId);
         Event savedEvent = saveEventWithProvidedTime(eventTime, customerId, tenantId);
         Event savedEvent = saveEventWithProvidedTime(eventTime, customerId, tenantId);
         Event savedEvent2 = saveEventWithProvidedTime(eventTime+1, customerId, tenantId);
         Event savedEvent2 = saveEventWithProvidedTime(eventTime+1, customerId, tenantId);
@@ -102,8 +102,8 @@ public abstract class BaseEventServiceTest extends AbstractServiceTest {
         long endTime = LocalDateTime.of(2016, Month.NOVEMBER, 1, 13, 0).toEpochSecond(ZoneOffset.UTC);
         long endTime = LocalDateTime.of(2016, Month.NOVEMBER, 1, 13, 0).toEpochSecond(ZoneOffset.UTC);
         long timeAfterEndTime = LocalDateTime.of(2016, Month.NOVEMBER, 1, 13, 30).toEpochSecond(ZoneOffset.UTC);
         long timeAfterEndTime = LocalDateTime.of(2016, Month.NOVEMBER, 1, 13, 30).toEpochSecond(ZoneOffset.UTC);
 
 
-        CustomerId customerId = new CustomerId(UUIDs.timeBased());
-        TenantId tenantId = new TenantId(UUIDs.timeBased());
+        CustomerId customerId = new CustomerId(Uuids.timeBased());
+        TenantId tenantId = new TenantId(Uuids.timeBased());
         saveEventWithProvidedTime(timeBeforeStartTime, customerId, tenantId);
         saveEventWithProvidedTime(timeBeforeStartTime, customerId, tenantId);
         Event savedEvent = saveEventWithProvidedTime(eventTime, customerId, tenantId);
         Event savedEvent = saveEventWithProvidedTime(eventTime, customerId, tenantId);
         Event savedEvent2 = saveEventWithProvidedTime(eventTime+1, customerId, tenantId);
         Event savedEvent2 = saveEventWithProvidedTime(eventTime+1, customerId, tenantId);
@@ -131,7 +131,7 @@ public abstract class BaseEventServiceTest extends AbstractServiceTest {
 
 
     private Event saveEventWithProvidedTime(long time, EntityId entityId, TenantId tenantId) throws IOException {
     private Event saveEventWithProvidedTime(long time, EntityId entityId, TenantId tenantId) throws IOException {
         Event event = generateEvent(tenantId, entityId, DataConstants.STATS, null);
         Event event = generateEvent(tenantId, entityId, DataConstants.STATS, null);
-        event.setId(new EventId(UUIDs.startOf(time)));
+        event.setId(new EventId(Uuids.startOf(time)));
         return eventService.save(event);
         return eventService.save(event);
     }
     }
-}
+}

@@ -15,7 +15,7 @@
  */
  */
 package org.thingsboard.server.dao.service.timeseries;
 package org.thingsboard.server.dao.service.timeseries;
 
 
-import com.datastax.driver.core.utils.UUIDs;
+import com.datastax.oss.driver.api.core.uuid.Uuids;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.junit.*;
 import org.junit.*;
 import org.thingsboard.server.common.data.EntityView;
 import org.thingsboard.server.common.data.EntityView;
@@ -84,7 +84,7 @@ public abstract class BaseTimeseriesServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void testFindAllLatest() throws Exception {
     public void testFindAllLatest() throws Exception {
-        DeviceId deviceId = new DeviceId(UUIDs.timeBased());
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
 
 
         saveEntries(deviceId, TS - 2);
         saveEntries(deviceId, TS - 2);
         saveEntries(deviceId, TS - 1);
         saveEntries(deviceId, TS - 1);
@@ -132,7 +132,7 @@ public abstract class BaseTimeseriesServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void testFindLatest() throws Exception {
     public void testFindLatest() throws Exception {
-        DeviceId deviceId = new DeviceId(UUIDs.timeBased());
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
 
 
         saveEntries(deviceId, TS - 2);
         saveEntries(deviceId, TS - 2);
         saveEntries(deviceId, TS - 1);
         saveEntries(deviceId, TS - 1);
@@ -151,7 +151,7 @@ public abstract class BaseTimeseriesServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void testFindByQueryAscOrder() throws Exception {
     public void testFindByQueryAscOrder() throws Exception {
-        DeviceId deviceId = new DeviceId(UUIDs.timeBased());
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
 
 
         saveEntries(deviceId, TS - 2);
         saveEntries(deviceId, TS - 2);
         saveEntries(deviceId, TS - 1);
         saveEntries(deviceId, TS - 1);
@@ -177,7 +177,7 @@ public abstract class BaseTimeseriesServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void testFindByQueryDescOrder() throws Exception {
     public void testFindByQueryDescOrder() throws Exception {
-        DeviceId deviceId = new DeviceId(UUIDs.timeBased());
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
 
 
         saveEntries(deviceId, TS - 2);
         saveEntries(deviceId, TS - 2);
         saveEntries(deviceId, TS - 1);
         saveEntries(deviceId, TS - 1);
@@ -203,7 +203,7 @@ public abstract class BaseTimeseriesServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void testDeleteDeviceTsDataWithOverwritingLatest() throws Exception {
     public void testDeleteDeviceTsDataWithOverwritingLatest() throws Exception {
-        DeviceId deviceId = new DeviceId(UUIDs.timeBased());
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
 
 
         saveEntries(deviceId, 10000);
         saveEntries(deviceId, 10000);
         saveEntries(deviceId, 20000);
         saveEntries(deviceId, 20000);
@@ -223,7 +223,7 @@ public abstract class BaseTimeseriesServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void testFindDeviceTsData() throws Exception {
     public void testFindDeviceTsData() throws Exception {
-        DeviceId deviceId = new DeviceId(UUIDs.timeBased());
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
         List<TsKvEntry> entries = new ArrayList<>();
         List<TsKvEntry> entries = new ArrayList<>();
 
 
         entries.add(save(deviceId, 5000, 100));
         entries.add(save(deviceId, 5000, 100));
@@ -374,7 +374,7 @@ public abstract class BaseTimeseriesServiceTest extends AbstractServiceTest {
 
 
     @Test
     @Test
     public void testFindDeviceLongAndDoubleTsData() throws Exception {
     public void testFindDeviceLongAndDoubleTsData() throws Exception {
-        DeviceId deviceId = new DeviceId(UUIDs.timeBased());
+        DeviceId deviceId = new DeviceId(Uuids.timeBased());
         List<TsKvEntry> entries = new ArrayList<>();
         List<TsKvEntry> entries = new ArrayList<>();
 
 
         entries.add(save(deviceId, 5000, 100));
         entries.add(save(deviceId, 5000, 100));