replaced slow query with multi-call of indexed query

application/src/main/java/org/thingsboard/server/service/install/update/DefaultDataUpdateService.java

@@ -313,9 +313,17 @@ public class DefaultDataUpdateService implements DataUpdateService {
     }
 
     private List<RuleNodeId> getRuleNodesIdsWithTypeAndVersionLessThan(String type, int toVersion) {
+        var ruleNodeIds = new ArrayList<RuleNodeId>();
+        for (int v = toVersion - 1; v >= 0; v--) {
+            ruleNodeIds.addAll(getRuleNodesIdsWithTypeAndVersion(type, v));
+        }
+        return ruleNodeIds;
+    }
+
+    private List<RuleNodeId> getRuleNodesIdsWithTypeAndVersion(String type, int version) {
         var ruleNodeIds = new ArrayList<RuleNodeId>();
         new PageDataIterable<>(pageLink ->
-                ruleChainService.findAllRuleNodeIdsByTypeAndVersionLessThan(type, toVersion, pageLink), DEFAULT_PAGE_SIZE
+                ruleChainService.findAllRuleNodeIdsByTypeAndVersion(type, version, pageLink), DEFAULT_PAGE_SIZE
         ).forEach(ruleNodeIds::add);
         return ruleNodeIds;
     }

common/dao-api/src/main/java/org/thingsboard/server/dao/rule/RuleChainService.java

@@ -100,10 +100,14 @@ public interface RuleChainService extends EntityDaoService {
 
     PageData<RuleNode> findAllRuleNodesByType(String type, PageLink pageLink);
 
+    @Deprecated(forRemoval = true, since = "3.6.3")
     PageData<RuleNode> findAllRuleNodesByTypeAndVersionLessThan(String type, int version, PageLink pageLink);
 
+    @Deprecated(forRemoval = true, since = "3.6.3")
     PageData<RuleNodeId> findAllRuleNodeIdsByTypeAndVersionLessThan(String type, int version, PageLink pageLink);
 
+    PageData<RuleNodeId> findAllRuleNodeIdsByTypeAndVersion(String type, int version, PageLink pageLink);
+
     List<RuleNode> findAllRuleNodesByIds(List<RuleNodeId> ruleNodeIds);
 
     RuleNode saveRuleNode(TenantId tenantId, RuleNode ruleNode);

dao/src/main/java/org/thingsboard/server/dao/rule/BaseRuleChainService.java

@@ -81,6 +81,7 @@ import static org.thingsboard.server.dao.service.Validator.validateId;
 import static org.thingsboard.server.dao.service.Validator.validateIds;
 import static org.thingsboard.server.dao.service.Validator.validatePageLink;
 import static org.thingsboard.server.dao.service.Validator.validatePositiveNumber;
+import static org.thingsboard.server.dao.service.Validator.validateNonNegativeNumber;
 import static org.thingsboard.server.dao.service.Validator.validateString;
 
 /**
@@ -737,6 +738,15 @@ public class BaseRuleChainService extends AbstractEntityService implements RuleC
         return ruleNodeDao.findAllRuleNodeIdsByTypeAndVersionLessThan(type, version, pageLink);
     }
 
+    @Override
+    public PageData<RuleNodeId> findAllRuleNodeIdsByTypeAndVersion(String type, int version, PageLink pageLink) {
+        log.trace("Executing findAllRuleNodeIdsByTypeAndVersion, type {}, pageLink {}, version {}", type, pageLink, version);
+        validateString(type, "Incorrect type of the rule node");
+        validateNonNegativeNumber(version, "Incorrect version. Version should be non-negative!");
+        validatePageLink(pageLink);
+        return ruleNodeDao.findAllRuleNodeIdsByTypeAndVersion(type, version, pageLink);
+    }
+
     @Override
     public List<RuleNode> findAllRuleNodesByIds(List<RuleNodeId> ruleNodeIds) {
         log.trace("Executing findAllRuleNodesByIds, ruleNodeIds {}", ruleNodeIds);

dao/src/main/java/org/thingsboard/server/dao/rule/RuleNodeDao.java

@@ -38,6 +38,8 @@ public interface RuleNodeDao extends Dao<RuleNode> {
 
     PageData<RuleNodeId> findAllRuleNodeIdsByTypeAndVersionLessThan(String type, int version, PageLink pageLink);
 
+    PageData<RuleNodeId> findAllRuleNodeIdsByTypeAndVersion(String type, int version, PageLink pageLink);
+
     List<RuleNode> findAllRuleNodeByIds(List<RuleNodeId> ruleNodeIds);
 
     List<RuleNode> findByExternalIds(RuleChainId ruleChainId, List<RuleNodeId> externalIds);

dao/src/main/java/org/thingsboard/server/dao/service/Validator.java

@@ -61,7 +61,7 @@ public class Validator {
 
 
     /**
-     * This method validate <code>long</code> value. If value isn't possitive than throw
+     * This method validate <code>long</code> value. If value isn't positive than throw
      * <code>IncorrectParameterException</code> exception
      *
      * @param val          the val
@@ -73,6 +73,19 @@ public class Validator {
         }
     }
 
+    /**
+     * This method validate <code>long</code> value. If value is negative than throw
+     * <code>IncorrectParameterException</code> exception
+     *
+     * @param val          the val
+     * @param errorMessage the error message for exception
+     */
+    public static void validateNonNegativeNumber(long val, String errorMessage) {
+        if (val < 0) {
+            throw new IncorrectParameterException(errorMessage);
+        }
+    }
+
     /**
      * This method validate <code>UUID</code> id. If id is null than throw
      * <code>IncorrectParameterException</code> exception

dao/src/main/java/org/thingsboard/server/dao/sql/rule/JpaRuleNodeDao.java

@@ -89,6 +89,16 @@ public class JpaRuleNodeDao extends JpaAbstractDao<RuleNodeEntity, RuleNode> imp
                 .mapData(RuleNodeId::new);
     }
 
+    @Override
+    public PageData<RuleNodeId> findAllRuleNodeIdsByTypeAndVersion(String type, int version, PageLink pageLink) {
+        return DaoUtil.pageToPageData(ruleNodeRepository
+                        .findAllRuleNodeIdsByTypeAndVersion(
+                                type,
+                                version,
+                                DaoUtil.toPageable(pageLink)))
+                .mapData(RuleNodeId::new);
+    }
+
     @Override
     public List<RuleNode> findAllRuleNodeByIds(List<RuleNodeId> ruleNodeIds) {
         return DaoUtil.convertDataList(ruleNodeRepository.findAllById(

dao/src/main/java/org/thingsboard/server/dao/sql/rule/RuleNodeRepository.java

@@ -43,7 +43,7 @@ public interface RuleNodeRepository extends JpaRepository<RuleNodeEntity, UUID>
                                                 Pageable pageable);
 
     @Query(nativeQuery = true, value = "SELECT * FROM rule_node r WHERE r.type = :ruleType " +
-            " AND configuration_version < :version " +
+            " AND r.configuration_version < :version " +
             " AND (:searchText IS NULL OR r.configuration ILIKE CONCAT('%', :searchText, '%'))")
     Page<RuleNodeEntity> findAllRuleNodesByTypeAndVersionLessThan(@Param("ruleType") String ruleType,
                                                                   @Param("version") int version,
@@ -55,6 +55,11 @@ public interface RuleNodeRepository extends JpaRepository<RuleNodeEntity, UUID>
                                                           @Param("version") int version,
                                                           Pageable pageable);
 
+    @Query("SELECT r.id FROM RuleNodeEntity r WHERE r.type = :ruleType AND r.configurationVersion = :version")
+    Page<UUID> findAllRuleNodeIdsByTypeAndVersion(@Param("ruleType") String ruleType,
+                                                  @Param("version") int version,
+                                                  Pageable pageable);
+
     List<RuleNodeEntity> findRuleNodesByRuleChainIdAndExternalIdIn(UUID ruleChainId, List<UUID> externalIds);
 
     @Transactional

dao/src/test/java/org/thingsboard/server/dao/sql/rule/JpaRuleNodeDaoTest.java

@@ -144,6 +144,25 @@ public class JpaRuleNodeDaoTest extends AbstractJpaDaoTest {
         assertEquals(10, ruleNodeIds.getData().size());
     }
 
+    @Test
+    public void testFindRuleNodeIdsByTypeAndVersion() {
+        PageData<RuleNodeId> ruleNodeIds = ruleNodeDao.findAllRuleNodeIdsByTypeAndVersion( "A", 0, new PageLink(10, 0, PREFIX_FOR_RULE_NODE_NAME));
+        assertEquals(20, ruleNodeIds.getTotalElements());
+        assertEquals(2, ruleNodeIds.getTotalPages());
+        assertEquals(10, ruleNodeIds.getData().size());
+
+        ruleNodeIds = ruleNodeDao.findAllRuleNodeIdsByTypeAndVersion( "A", 0, new PageLink(10, 0));
+        assertEquals(20, ruleNodeIds.getTotalElements());
+        assertEquals(2, ruleNodeIds.getTotalPages());
+        assertEquals(10, ruleNodeIds.getData().size());
+
+        // test - search text ignored
+        ruleNodeIds = ruleNodeDao.findAllRuleNodeIdsByTypeAndVersion( "A", 0, new PageLink(10, 0, StringUtils.randomAlphabetic(5)));
+        assertEquals(20, ruleNodeIds.getTotalElements());
+        assertEquals(2, ruleNodeIds.getTotalPages());
+        assertEquals(10, ruleNodeIds.getData().size());
+    }
+
     @Test
     public void testFindAllRuleNodeByIds() {
         var fromUUIDs = ruleNodeIds.stream().map(RuleNodeId::new).collect(Collectors.toList());