removed unnecessary methods

application/src/main/java/org/thingsboard/server/service/entitiy/cf/CalculatedFieldState.java

@@ -15,6 +15,7 @@
  */
 package org.thingsboard.server.service.entitiy.cf;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
 import com.fasterxml.jackson.annotation.JsonSubTypes;
 import com.fasterxml.jackson.annotation.JsonTypeInfo;
 import org.thingsboard.server.common.data.cf.CalculatedFieldConfiguration;
@@ -32,6 +33,7 @@ import java.util.Map;
 })
 public interface CalculatedFieldState {
 
+    @JsonIgnore
     CalculatedFieldType getType();
 
     void performCalculation(Map<String, String> argumentValues, CalculatedFieldConfiguration calculatedFieldConfiguration, boolean initialCalculation);

application/src/main/java/org/thingsboard/server/service/entitiy/cf/DefaultTbCalculatedFieldService.java

@@ -96,7 +96,7 @@ public class DefaultTbCalculatedFieldService extends AbstractTbEntityService imp
     private final ConcurrentMap<CalculatedFieldId, List<CalculatedFieldLink>> calculatedFieldLinks = new ConcurrentHashMap<>();
     private final ConcurrentMap<String, CalculatedFieldCtx> states = new ConcurrentHashMap<>();
 
-    @Value("${state.initFetchPackSize:50000}")
+    @Value("${calculatedField.initFetchPackSize:50000}")
     @Getter
     private int initFetchPackSize;
 
@@ -145,7 +145,10 @@ public class DefaultTbCalculatedFieldService extends AbstractTbEntityService imp
             CalculatedField cf = calculatedFieldService.findById(tenantId, calculatedFieldId);
             if (proto.getUpdated()) {
                 log.info("Executing onCalculatedFieldUpdate, calculatedFieldId=[{}]", calculatedFieldId);
-                onCalculatedFieldUpdate(cf, callback);
+                boolean shouldReinit = onCalculatedFieldUpdate(cf, callback);
+                if (!shouldReinit) {
+                    return;
+                }
             }
             List<CalculatedFieldLink> links = calculatedFieldService.findAllCalculatedFieldLinksById(tenantId, calculatedFieldId);
             if (cf != null) {
@@ -172,12 +175,13 @@ public class DefaultTbCalculatedFieldService extends AbstractTbEntityService imp
                     default ->
                             throw new IllegalArgumentException("Entity type '" + calculatedFieldId.getEntityType() + "' does not support calculated fields.");
                 }
-                log.info("Successfully processed calculated field message for calculatedFieldId: [{}]", calculatedFieldId);
             } else {
                 //Calculated field was probably deleted while message was in queue;
                 log.warn("Calculated field not found, possibly deleted: {}", calculatedFieldId);
                 callback.onSuccess();
             }
+            callback.onSuccess();
+            log.info("Successfully processed calculated field message for calculatedFieldId: [{}]", calculatedFieldId);
         } catch (Exception e) {
             log.trace("Failed to process calculated field msg: [{}]", proto, e);
             callback.onFailure(e);
@@ -235,17 +239,20 @@ public class DefaultTbCalculatedFieldService extends AbstractTbEntityService imp
         }
     }
 
-    private void onCalculatedFieldUpdate(CalculatedField newCalculatedField, TbCallback callback) {
+    private boolean onCalculatedFieldUpdate(CalculatedField newCalculatedField, TbCallback callback) {
         CalculatedField oldCalculatedField = calculatedFields.get(newCalculatedField.getId());
-        if (hasSignificantChanged(oldCalculatedField, newCalculatedField)) {
+        boolean shouldReinit = true;
+        if (hasSignificantChanges(oldCalculatedField, newCalculatedField)) {
             onCalculatedFieldDelete(newCalculatedField.getId(), callback);
         } else {
             calculatedFields.put(newCalculatedField.getId(), newCalculatedField);
             callback.onSuccess();
+            shouldReinit = false;
         }
+        return shouldReinit;
     }
 
-    private boolean hasSignificantChanged(CalculatedField oldCalculatedField, CalculatedField newCalculatedField) {
+    private boolean hasSignificantChanges(CalculatedField oldCalculatedField, CalculatedField newCalculatedField) {
         if (oldCalculatedField == null) {
             return true;
         }
@@ -255,9 +262,9 @@ public class DefaultTbCalculatedFieldService extends AbstractTbEntityService imp
         CalculatedFieldConfiguration newConfig = newCalculatedField.getConfiguration();
         boolean argumentsChanged = !oldConfig.getArguments().equals(newConfig.getArguments());
         boolean outputTypeChanged = !oldConfig.getOutput().getType().equals(newConfig.getOutput().getType());
-        boolean outputNameChanged = !oldConfig.getOutput().getName().equals(newConfig.getOutput().getName());
+        boolean outputExpressionChanged = !oldConfig.getOutput().getExpression().equals(newConfig.getOutput().getExpression());
 
-        return entityIdChanged || typeChanged || argumentsChanged || outputTypeChanged || outputNameChanged;
+        return entityIdChanged || typeChanged || argumentsChanged || outputTypeChanged || outputExpressionChanged;
     }
 
     private void fetchCalculatedFields() {
@@ -344,6 +351,7 @@ public class DefaultTbCalculatedFieldService extends AbstractTbEntityService imp
         } else {
             CalculatedFieldState newState = createStateByType(calculatedField.getType());
             newState.performCalculation(argumentValues, calculatedField.getConfiguration(), true);
+            state = newState;
         }
         calculatedFieldCtx.setState(state);
 

application/src/main/resources/thingsboard.yml

@@ -424,6 +424,10 @@ sql:
     pool_size: "${SQL_RELATIONS_POOL_SIZE:4}" # This value has to be reasonably small to prevent the relation query from blocking all other DB calls
     query_timeout: "${SQL_RELATIONS_QUERY_TIMEOUT_SEC:20}" # This value has to be reasonably small to prevent the relation query from blocking all other DB calls
 
+# Calculated Field parameters
+calculatedField:
+  initFetchPackSize: "${INIT_FETCH_PACK_SIZE:50000}"
+
 rocksdb:
   # Rocksdb path
   db_path: "${ROCKS_DB_PATH:${java.io.tmpdir}/rocksdb}"

common/dao-api/src/main/java/org/thingsboard/server/dao/cf/CalculatedFieldService.java

@@ -15,6 +15,7 @@
  */
 package org.thingsboard.server.dao.cf;
 
+import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.cf.CalculatedField;
 import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
@@ -33,6 +34,8 @@ public interface CalculatedFieldService extends EntityDaoService {
 
     CalculatedField findById(TenantId tenantId, CalculatedFieldId calculatedFieldId);
 
+    ListenableFuture<CalculatedField> findCalculatedFieldByIdAsync(TenantId tenantId, CalculatedFieldId calculatedFieldId);
+
     List<CalculatedField> findAllCalculatedFields();
 
     PageData<CalculatedField> findAllCalculatedFields(PageLink pageLink);
@@ -45,13 +48,15 @@ public interface CalculatedFieldService extends EntityDaoService {
 
     CalculatedFieldLink findCalculatedFieldLinkById(TenantId tenantId, CalculatedFieldLinkId calculatedFieldLinkId);
 
+    ListenableFuture<CalculatedFieldLink> findCalculatedFieldLinkByIdAsync(TenantId tenantId, CalculatedFieldLinkId calculatedFieldLinkId);
+
     List<CalculatedFieldLink> findAllCalculatedFieldLinks();
 
     List<CalculatedFieldLink> findAllCalculatedFieldLinksById(TenantId tenantId, CalculatedFieldId calculatedFieldId);
 
-    PageData<CalculatedFieldLink> findAllCalculatedFieldLinks(PageLink pageLink);
+    ListenableFuture<List<CalculatedFieldLink>> findAllCalculatedFieldLinksByIdAsync(TenantId tenantId, CalculatedFieldId calculatedFieldId);
 
-    boolean existsByEntityId(TenantId tenantId, EntityId entityId);
+    PageData<CalculatedFieldLink> findAllCalculatedFieldLinks(PageLink pageLink);
 
     boolean referencedInAnyCalculatedField(TenantId tenantId, EntityId referencedEntityId);
 

dao/src/main/java/org/thingsboard/server/dao/cf/BaseCalculatedFieldService.java

@@ -15,6 +15,7 @@
  */
 package org.thingsboard.server.dao.cf;
 
+import com.google.common.util.concurrent.ListenableFuture;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
@@ -30,7 +31,9 @@ import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
 import org.thingsboard.server.dao.entity.AbstractEntityService;
+import org.thingsboard.server.dao.eventsourcing.DeleteEntityEvent;
 import org.thingsboard.server.dao.eventsourcing.SaveEntityEvent;
+import org.thingsboard.server.dao.exception.IncorrectParameterException;
 import org.thingsboard.server.dao.service.DataValidator;
 
 import java.util.List;
@@ -55,14 +58,14 @@ public class BaseCalculatedFieldService extends AbstractEntityService implements
 
     @Override
     public CalculatedField save(CalculatedField calculatedField) {
-        calculatedFieldDataValidator.validate(calculatedField, CalculatedField::getTenantId);
+        CalculatedField oldCalculatedField = calculatedFieldDataValidator.validate(calculatedField, CalculatedField::getTenantId);
         try {
             TenantId tenantId = calculatedField.getTenantId();
             log.trace("Executing save calculated field, [{}]", calculatedField);
             CalculatedField savedCalculatedField = calculatedFieldDao.save(tenantId, calculatedField);
             createOrUpdateCalculatedFieldLink(tenantId, savedCalculatedField);
             eventPublisher.publishEvent(SaveEntityEvent.builder().tenantId(savedCalculatedField.getTenantId()).entityId(savedCalculatedField.getId())
-                    .entity(savedCalculatedField).created(calculatedField.getId() == null).build());
+                    .entity(savedCalculatedField).oldEntity(oldCalculatedField).created(calculatedField.getId() == null).build());
             return savedCalculatedField;
         } catch (Exception e) {
             checkConstraintViolation(e,
@@ -80,6 +83,13 @@ public class BaseCalculatedFieldService extends AbstractEntityService implements
         return calculatedFieldDao.findById(tenantId, calculatedFieldId.getId());
     }
 
+    @Override
+    public ListenableFuture<CalculatedField> findCalculatedFieldByIdAsync(TenantId tenantId, CalculatedFieldId calculatedFieldId) {
+        log.trace("Executing findCalculatedFieldByIdAsync [{}]", calculatedFieldId);
+        validateId(calculatedFieldId, id -> INCORRECT_CALCULATED_FIELD_ID + id);
+        return calculatedFieldDao.findByIdAsync(tenantId, calculatedFieldId.getId());
+    }
+
     @Override
     public List<CalculatedField> findAllCalculatedFields() {
         log.trace("Executing findAll");
@@ -95,10 +105,28 @@ public class BaseCalculatedFieldService extends AbstractEntityService implements
 
     @Override
     public void deleteCalculatedField(TenantId tenantId, CalculatedFieldId calculatedFieldId) {
-        log.trace("Executing deleteCalculatedField, tenantId [{}], calculatedFieldId [{}]", tenantId, calculatedFieldId);
         validateId(tenantId, id -> INCORRECT_TENANT_ID + id);
         validateId(calculatedFieldId, id -> INCORRECT_CALCULATED_FIELD_ID + id);
-        calculatedFieldDao.removeById(tenantId, calculatedFieldId.getId());
+        deleteEntity(tenantId, calculatedFieldId, false);
+    }
+
+    @Override
+    public void deleteEntity(TenantId tenantId, EntityId id, boolean force) {
+        CalculatedField calculatedField = calculatedFieldDao.findById(tenantId, id.getId());
+        if (calculatedField == null) {
+            if (force) {
+                return;
+            } else {
+                throw new IncorrectParameterException("Unable to delete non-existent calculated field.");
+            }
+        }
+        deleteCalculatedField(tenantId, calculatedField);
+    }
+
+    private void deleteCalculatedField(TenantId tenantId, CalculatedField calculatedField) {
+        log.trace("Executing deleteCalculatedField, tenantId [{}], calculatedFieldId [{}]", tenantId, calculatedField.getId());
+        calculatedFieldDao.removeById(tenantId, calculatedField.getUuidId());
+        eventPublisher.publishEvent(DeleteEntityEvent.builder().tenantId(tenantId).entityId(calculatedField.getId()).entity(calculatedField).build());
     }
 
     @Override
@@ -125,6 +153,14 @@ public class BaseCalculatedFieldService extends AbstractEntityService implements
         return calculatedFieldLinkDao.findById(tenantId, calculatedFieldLinkId.getId());
     }
 
+    @Override
+    public ListenableFuture<CalculatedFieldLink> findCalculatedFieldLinkByIdAsync(TenantId tenantId, CalculatedFieldLinkId calculatedFieldLinkId) {
+        log.trace("Executing findCalculatedFieldLinkByIdAsync [{}]", calculatedFieldLinkId);
+        validateId(tenantId, id -> INCORRECT_TENANT_ID + id);
+        validateId(calculatedFieldLinkId, id -> "Incorrect calculatedFieldLinkId " + id);
+        return calculatedFieldLinkDao.findByIdAsync(tenantId, calculatedFieldLinkId.getId());
+    }
+
     @Override
     public List<CalculatedFieldLink> findAllCalculatedFieldLinks() {
         log.trace("Executing findAllCalculatedFieldLinks");
@@ -137,6 +173,12 @@ public class BaseCalculatedFieldService extends AbstractEntityService implements
         return calculatedFieldLinkDao.findCalculatedFieldLinksByCalculatedFieldId(tenantId, calculatedFieldId);
     }
 
+    @Override
+    public ListenableFuture<List<CalculatedFieldLink>> findAllCalculatedFieldLinksByIdAsync(TenantId tenantId, CalculatedFieldId calculatedFieldId) {
+        log.trace("Executing findAllCalculatedFieldLinksByIdAsync, calculatedFieldId [{}]", calculatedFieldId);
+        return calculatedFieldLinkDao.findCalculatedFieldLinksByCalculatedFieldIdAsync(tenantId, calculatedFieldId);
+    }
+
     @Override
     public PageData<CalculatedFieldLink> findAllCalculatedFieldLinks(PageLink pageLink) {
         log.trace("Executing findAllCalculatedFieldLinks, pageLink [{}]", pageLink);
@@ -144,11 +186,6 @@ public class BaseCalculatedFieldService extends AbstractEntityService implements
         return calculatedFieldLinkDao.findAll(pageLink);
     }
 
-    @Override
-    public boolean existsByEntityId(TenantId tenantId, EntityId entityId) {
-        return calculatedFieldDao.existsByTenantIdAndEntityId(tenantId, entityId);
-    }
-
     @Override
     public boolean referencedInAnyCalculatedField(TenantId tenantId, EntityId referencedEntityId) {
         return calculatedFieldDao.findAllByTenantId(tenantId).stream()

dao/src/main/java/org/thingsboard/server/dao/cf/CalculatedFieldDao.java

@@ -26,8 +26,6 @@ import java.util.List;
 
 public interface CalculatedFieldDao extends Dao<CalculatedField> {
 
-    boolean existsByTenantIdAndEntityId(TenantId tenantId, EntityId entityId);
-
     List<CalculatedField> findAllByTenantId(TenantId tenantId);
 
     List<CalculatedField> findAll();

dao/src/main/java/org/thingsboard/server/dao/cf/CalculatedFieldLinkDao.java

@@ -15,6 +15,7 @@
  */
 package org.thingsboard.server.dao.cf;
 
+import com.google.common.util.concurrent.ListenableFuture;
 import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
 import org.thingsboard.server.common.data.id.TenantId;
@@ -28,6 +29,8 @@ public interface CalculatedFieldLinkDao extends Dao<CalculatedFieldLink> {
 
     List<CalculatedFieldLink> findCalculatedFieldLinksByCalculatedFieldId(TenantId tenantId, CalculatedFieldId calculatedFieldId);
 
+    ListenableFuture<List<CalculatedFieldLink>> findCalculatedFieldLinksByCalculatedFieldIdAsync(TenantId tenantId, CalculatedFieldId calculatedFieldId);
+
     List<CalculatedFieldLink> findAll();
 
     PageData<CalculatedFieldLink> findAll(PageLink pageLink);

dao/src/main/java/org/thingsboard/server/dao/sql/cf/JpaCalculatedFieldDao.java

@@ -18,7 +18,6 @@ package org.thingsboard.server.dao.sql.cf;
 import jakarta.transaction.Transactional;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.EntityType;
@@ -31,7 +30,6 @@ import org.thingsboard.server.dao.DaoUtil;
 import org.thingsboard.server.dao.cf.CalculatedFieldDao;
 import org.thingsboard.server.dao.model.sql.CalculatedFieldEntity;
 import org.thingsboard.server.dao.sql.JpaAbstractDao;
-import org.thingsboard.server.dao.sql.device.NativeDeviceRepository;
 import org.thingsboard.server.dao.util.SqlDao;
 
 import java.util.List;
@@ -46,11 +44,6 @@ public class JpaCalculatedFieldDao extends JpaAbstractDao<CalculatedFieldEntity,
     private final CalculatedFieldRepository calculatedFieldRepository;
     private final NativeCalculatedFieldRepository nativeCalculatedFieldRepository;
 
-    @Override
-    public boolean existsByTenantIdAndEntityId(TenantId tenantId, EntityId entityId) {
-        return calculatedFieldRepository.existsByTenantIdAndEntityId(tenantId.getId(), entityId.getId());
-    }
-
     @Override
     public List<CalculatedField> findAllByTenantId(TenantId tenantId) {
         return DaoUtil.convertDataList(calculatedFieldRepository.findAllByTenantId(tenantId.getId()));

dao/src/main/java/org/thingsboard/server/dao/sql/cf/JpaCalculatedFieldLinkDao.java

@@ -15,6 +15,7 @@
  */
 package org.thingsboard.server.dao.sql.cf;
 
+import com.google.common.util.concurrent.ListenableFuture;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.data.jpa.repository.JpaRepository;
@@ -22,7 +23,6 @@ import org.springframework.stereotype.Component;
 import org.thingsboard.server.common.data.EntityType;
 import org.thingsboard.server.common.data.cf.CalculatedFieldLink;
 import org.thingsboard.server.common.data.id.CalculatedFieldId;
-import org.thingsboard.server.common.data.id.EntityId;
 import org.thingsboard.server.common.data.id.TenantId;
 import org.thingsboard.server.common.data.page.PageData;
 import org.thingsboard.server.common.data.page.PageLink;
@@ -49,6 +49,11 @@ public class JpaCalculatedFieldLinkDao extends JpaAbstractDao<CalculatedFieldLin
         return DaoUtil.convertDataList(calculatedFieldLinkRepository.findAllByTenantIdAndCalculatedFieldId(tenantId.getId(), calculatedFieldId.getId()));
     }
 
+    @Override
+    public ListenableFuture<List<CalculatedFieldLink>> findCalculatedFieldLinksByCalculatedFieldIdAsync(TenantId tenantId, CalculatedFieldId calculatedFieldId) {
+        return service.submit(() -> findCalculatedFieldLinksByCalculatedFieldId(tenantId, calculatedFieldId));
+    }
+
     @Override
     public List<CalculatedFieldLink> findAll() {
         return DaoUtil.convertDataList(calculatedFieldLinkRepository.findAll());