.gitlab-ci.yml and Dockerfile added

.gitlab-ci.yml

@@ -0,0 +1,33 @@
+image:
+  name: maven:3-eclipse-temurin-21-alpine
+  pull_policy: if-not-present
+
+stages:
+  - build
+  - test
+  - publish
+
+build:
+  stage: build
+  script:
+    - mvn clean compile -Dmaven.test.skip=true
+  resource_group: indic-search-service-test
+
+test:
+  stage: test
+  script:
+    - mvn clean prepare-package
+  artifacts:
+    name: "$CI_COMMIT_REF_NAME"
+    expire_in: 1 day
+    paths:
+      - target/site
+      - target/jacoco.exec
+  resource_group: indic-search-service-test
+
+publish:
+  stage: publish
+  when: manual
+  script:
+    - mvn -P with-docker-registry clean install -Dmaven.test.skip=true
+  resource_group: indic-search-service-test

Dockerfile

@@ -0,0 +1,36 @@
+FROM eclipse-temurin:21-jre-alpine
+
+ENV TZ="Europe/Moscow"
+
+USER root
+
+WORKDIR /opt/app
+COPY maven/elastic-apm-agent-1.50.0.jar elastic-apm-agent.jar
+COPY maven/indic-search-service*.jar indic-search-service.jar
+COPY maven/application.properties application.properties
+
+CMD java \
+    -javaagent:/opt/app/elastic-apm-agent.jar \
+    -Xmx${XMX_MB}m \
+    -XX:+UseZGC \
+    -XX:+ZGenerational \
+    -Dcom.sun.management.jmxremote=true \
+    -Dcom.sun.management.jmxremote.port=1234 \
+    -Dcom.sun.management.jmxremote.authenticate=false \
+    -Dcom.sun.management.jmxremote.ssl=false \
+    -Dnode_routing_suffix=${JVM_ROUTE} \
+    -Delastic.apm.service_name="${APM_SERVICE_NAME}" \
+    -Delastic.apm.server_urls="${APM_SERVER_URLS}" \
+    -Delastic.apm.application_packages=ru.nbch \
+    -Delastic.apm.environment="${APM_ENVIRONMENT}" \
+    -Delastic.apm.service_node_name="${APM_SERVICE_NODE_NAME}" \
+    -Delastic.apm.hostname="${APM_SERVICE_NODE_NAME}" \
+    -Delastic.apm.service_version=${APM_SERVICE_VERSION} \
+    -Delastic.apm.enable_log_correlation=true \
+    -Delastic.apm.stack_trace_limit=0 \
+    -Delastic.apm.span_stack_trace_min_duration=-1ms \
+    -Dlog4j2.formatMsgNoLookups=true \
+    -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:5555 \
+    ${JAVA_OPTS} \
+    -jar indic-search-service.jar \
+    --spring.config.location=application.properties

src/main/java/ru/nbch/indicsearchservice/aggregator/FileAggregator.java

@@ -0,0 +1,18 @@
+package ru.nbch.indicsearchservice.aggregator;
+
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.UUID;
+import org.apache.commons.lang3.mutable.MutableLong;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+
+public interface FileAggregator {
+    Path aggregateFiles(UUID taskId,
+                        DataType dataType,
+                        SearchParameter searchParameter,
+                        String searchValue,
+                        String memberCode,
+                        Map<String, Path> tableFileMap,
+                        MutableLong rowCounter);
+}

src/main/java/ru/nbch/indicsearchservice/aggregator/FileAggregatorCommon.java

@@ -0,0 +1,369 @@
+package ru.nbch.indicsearchservice.aggregator;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import org.apache.commons.lang3.mutable.MutableLong;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.util.IndicSearchCommon;
+import ru.nbch.indicsearchservice.util.MovableBufferedReader;
+
+@Component
+public class FileAggregatorCommon {
+    private static final List<String> RU_UID_CHILD_TABLES = List.of(
+        "RU_TRADE",
+        "RU_ACCOUNT_AMT",
+        "RU_COBORROWER",
+        "RU_PAYMT_CONDITION",
+        "RU_OVERALLVAL",
+        "RU_AMENDMENT",
+        "RU_FUNDDATE",
+        "RU_ARREAR",
+        "RU_DUEARREAR",
+        "RU_PASTDUEARREAR",
+        "RU_PAYMT",
+        "RU_MONTHAVERPAYMT",
+        "RU_SOURCENONMONETOBLIG",
+        "RU_SUBJECTNONMONETOBLIG",
+        "RU_COLLATERAL",
+        "RU_GUARANTOR",
+        "RU_INDEPGUARANTOR",
+        "RU_COLLATINSURED",
+        "RU_COLLATREPAY",
+        "RU_GUARANTEEREPAY",
+        "RU_OBLIGTERMINATION",
+        "RU_SUBMITHOLD",
+        "RU_ACQUIRERLEGAL",
+        "RU_ACQUIRERINDIVID",
+        "RU_SERVICECO",
+        "RU_OBLIGACCOUNT",
+        "RU_LEGALRECORD",
+        "RU_OBLIGSRCBANKRUPT",
+        "RU_OBLIGSRCLIQUID",
+        "RU_AMOUNT_INFO",
+        "RU_CONTRACT_TERMS_CHANGES",
+        "RU_ALL_ARREARS"
+    );
+    private static final List<String> ACCOUNT_CHILD_TABLES = List.of(
+        "ACCOUNT_AMEND",
+        "PAYMENT",
+        "COLLATERAL",
+        "GUARANTOR",
+        "BANK_GUARANTEE"
+    );
+
+    void aggregateRuUidFiles(BufferedWriter aggregatedFileWriter,
+                             Map<String, Path> tableFileMap,
+                             String memberCode,
+                             MutableLong rowCounter) {
+        try (BufferedReader ruUidFileReader = Files.newBufferedReader(tableFileMap.get("RU_UID"))) {
+            Map<String, MovableBufferedReader> childTablesReadersMap = new LinkedHashMap<>();
+            for (String tableName : RU_UID_CHILD_TABLES) {
+                if (!tableFileMap.containsKey(tableName)) {
+                    continue;
+                }
+
+                MovableBufferedReader childTablesReader = new MovableBufferedReader(Files.newBufferedReader(tableFileMap.get(tableName)));
+                if (childTablesReader.getCurrentLine() != null) {
+                    childTablesReadersMap.put(tableName, childTablesReader);
+                }
+            }
+
+            String ruUidLine;
+            while ((ruUidLine = ruUidFileReader.readLine()) != null) {
+                List<String> lineList = Arrays.asList(ruUidLine.split("%%%"));
+                Optional<String> foundMemberCode = IndicSearchCommon.getRowValue(lineList, "MEMBER_CODE");
+
+                if (foundMemberCode.isPresent() && !foundMemberCode.get().startsWith(memberCode)) {
+                    continue;
+                }
+
+                aggregatedFileWriter.write(ruUidLine);
+                aggregatedFileWriter.newLine();
+                rowCounter.increment();
+
+                Optional<String> foundRuUidSerialNum = IndicSearchCommon.getRowValue(lineList, "SERIAL_NUM");
+                if (foundRuUidSerialNum.isEmpty()) {
+                    throw new InternalException("SERIAL_NUM was not found in line " + ruUidLine);
+                }
+                Long ruUidSerialNum = Long.parseLong(foundRuUidSerialNum.get());
+
+                for (Map.Entry<String, MovableBufferedReader> entry : childTablesReadersMap.entrySet()) {
+                    String childTableName = entry.getKey();
+                    MovableBufferedReader childReader = entry.getValue();
+
+                    String childLine = childReader.getCurrentLine();
+                    if (childLine == null) {
+                        continue;
+                    }
+
+                    List<String> childLineList = Arrays.asList(childLine.split("%%%"));
+                    Optional<String> foundChildAccSerialNum = IndicSearchCommon.getRowValue(childLineList, "ACC_SERIAL_NUM");
+                    if (foundChildAccSerialNum.isEmpty()) {
+                        throw new InternalException("ACC_SERIAL_NUM was not found in table " + childTableName + " in line " + childLine);
+                    }
+                    Long childAccSerialNum = Long.parseLong(foundChildAccSerialNum.get());
+
+                    if (ruUidSerialNum > childAccSerialNum) {
+                        while ((childLine = childReader.nextLine()) != null) {
+                            childLineList = Arrays.asList(childLine.split("%%%"));
+                            foundChildAccSerialNum = IndicSearchCommon.getRowValue(childLineList, "ACC_SERIAL_NUM");
+                            if (foundChildAccSerialNum.isEmpty()) {
+                                throw new InternalException("ACC_SERIAL_NUM was not found in table " + childTableName + " in line " + childLine);
+                            }
+                            childAccSerialNum = Long.parseLong(foundChildAccSerialNum.get());
+
+                            if (childAccSerialNum.equals(ruUidSerialNum)) {
+                                aggregatedFileWriter.write(childLine);
+                                aggregatedFileWriter.newLine();
+                                rowCounter.increment();
+
+                                if (childTableName.equals("RU_COLLATERAL")) {
+                                    aggregateBlocksTableFile(childTableName, aggregatedFileWriter, tableFileMap, memberCode, rowCounter);
+                                }
+                            }
+
+                            if (childAccSerialNum > ruUidSerialNum) {
+                                break;
+                            }
+                        }
+                    } else if (ruUidSerialNum.equals(childAccSerialNum)) {
+                        aggregatedFileWriter.write(childLine);
+                        aggregatedFileWriter.newLine();
+                        rowCounter.increment();
+
+                        if (childTableName.equals("RU_COLLATERAL")) {
+                            aggregateBlocksTableFile(childTableName, aggregatedFileWriter, tableFileMap, memberCode, rowCounter);
+                        }
+
+                        while ((childLine = childReader.nextLine()) != null) {
+                            childLineList = Arrays.asList(childLine.split("%%%"));
+                            foundChildAccSerialNum = IndicSearchCommon.getRowValue(childLineList, "ACC_SERIAL_NUM");
+                            if (foundChildAccSerialNum.isEmpty()) {
+                                throw new InternalException("ACC_SERIAL_NUM was not found in table " + childTableName + " in line " + childLine);
+                            }
+                            childAccSerialNum = Long.parseLong(foundChildAccSerialNum.get());
+
+                            if (childAccSerialNum.equals(ruUidSerialNum)) {
+                                aggregatedFileWriter.write(childLine);
+                                aggregatedFileWriter.newLine();
+                                rowCounter.increment();
+
+                                if (childTableName.equals("RU_COLLATERAL")) {
+                                    aggregateBlocksTableFile(childTableName, aggregatedFileWriter, tableFileMap, memberCode, rowCounter);
+                                }
+                            }
+
+                            if (childAccSerialNum > ruUidSerialNum) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            for (MovableBufferedReader br : childTablesReadersMap.values()) {
+                br.getReader().close();
+            }
+        } catch (IOException e) {
+            throw new InternalException(e);
+        }
+    }
+
+    void aggregateBlocksTableFile(String parentTableName, BufferedWriter aggregatedFileWriter, Map<String, Path> tableFileMap, String memberCode, MutableLong rowCounter) {
+        try (BufferedReader parentFileReader = Files.newBufferedReader(tableFileMap.get(parentTableName));
+             MovableBufferedReader blocksFileReader = new MovableBufferedReader(Files.newBufferedReader(tableFileMap.get(parentTableName + "_BLOCKS")))) {
+            String parentLine;
+            while ((parentLine = parentFileReader.readLine()) != null) {
+                List<String> parentLineList = Arrays.asList(parentLine.split("%%%"));
+                Optional<String> foundMemberCode = IndicSearchCommon.getRowValue(parentLineList, "MEMBER_CODE");
+
+                if (foundMemberCode.isPresent() && !foundMemberCode.get().startsWith(memberCode)) {
+                    continue;
+                }
+
+                aggregatedFileWriter.write(parentLine);
+                aggregatedFileWriter.newLine();
+                rowCounter.increment();
+
+                Optional<String> foundParentSerialNum = IndicSearchCommon.getRowValue(parentLineList, "SERIAL_NUM");
+                if (foundParentSerialNum.isEmpty()) {
+                    throw new InternalException("SERIAL_NUM was not found in line " + parentLine);
+                }
+                Long parentSerialNum = Long.parseLong(foundParentSerialNum.get());
+
+                String blocksLine = blocksFileReader.getCurrentLine();
+                if (blocksLine == null) {
+                    continue;
+                }
+
+                List<String> childLineList = Arrays.asList(blocksLine.split("%%%"));
+                Optional<String> foundChildParentSerialNum = IndicSearchCommon.getRowValue(childLineList, "PARENT_SERIAL_NUM");
+                if (foundChildParentSerialNum.isEmpty()) {
+                    throw new InternalException("PARENT_SERIAL_NUM was not found in line " + blocksLine);
+                }
+                Long blocksParentSerialNum = Long.parseLong(foundChildParentSerialNum.get());
+
+                if (parentSerialNum > blocksParentSerialNum) {
+                    while ((blocksLine = blocksFileReader.nextLine()) != null) {
+                        childLineList = Arrays.asList(blocksLine.split("%%%"));
+                        foundChildParentSerialNum = IndicSearchCommon.getRowValue(childLineList, "PARENT_SERIAL_NUM");
+                        if (foundChildParentSerialNum.isEmpty()) {
+                            throw new InternalException("PARENT_SERIAL_NUM was not found in line " + blocksLine);
+                        }
+                        blocksParentSerialNum = Long.parseLong(foundChildParentSerialNum.get());
+
+                        if (blocksParentSerialNum.equals(parentSerialNum)) {
+                            aggregatedFileWriter.write(blocksLine);
+                            aggregatedFileWriter.newLine();
+                            rowCounter.increment();
+                        }
+
+                        if (blocksParentSerialNum > parentSerialNum) {
+                            break;
+                        }
+                    }
+                } else if (parentSerialNum.equals(blocksParentSerialNum)) {
+                    aggregatedFileWriter.write(blocksLine);
+                    aggregatedFileWriter.newLine();
+                    rowCounter.increment();
+
+                    while ((blocksLine = blocksFileReader.nextLine()) != null) {
+                        childLineList = Arrays.asList(blocksLine.split("%%%"));
+                        foundChildParentSerialNum = IndicSearchCommon.getRowValue(childLineList, "PARENT_SERIAL_NUM");
+                        if (foundChildParentSerialNum.isEmpty()) {
+                            throw new InternalException("PARENT_SERIAL_NUM was not found in line " + blocksLine);
+                        }
+                        blocksParentSerialNum = Long.parseLong(foundChildParentSerialNum.get());
+
+                        if (blocksParentSerialNum.equals(parentSerialNum)) {
+                            aggregatedFileWriter.write(blocksLine);
+                            aggregatedFileWriter.newLine();
+                            rowCounter.increment();
+                        }
+
+                        if (blocksParentSerialNum > parentSerialNum) {
+                            break;
+                        }
+                    }
+                }
+            }
+        } catch (IOException e) {
+            throw new InternalException(e);
+        }
+    }
+
+    void aggregateAccountFiles(BufferedWriter aggregatedFileWriter,
+                               Map<String, Path> tableFileMap,
+                               String memberCode,
+                               MutableLong rowCounter) {
+        try (BufferedReader accountFileReader = Files.newBufferedReader(tableFileMap.get("ACCOUNT"))) {
+            Map<String, MovableBufferedReader> childTablesReadersMap = new LinkedHashMap<>();
+            for (String tableName : ACCOUNT_CHILD_TABLES) {
+                if (!tableFileMap.containsKey(tableName)) {
+                    continue;
+                }
+
+                MovableBufferedReader childTablesReader = new MovableBufferedReader(Files.newBufferedReader(tableFileMap.get(tableName)));
+                if (childTablesReader.getCurrentLine() != null) {
+                    childTablesReadersMap.put(tableName, childTablesReader);
+                }
+            }
+
+            String accountLine;
+            while ((accountLine = accountFileReader.readLine()) != null) {
+                List<String> lineList = Arrays.asList(accountLine.split("%%%"));
+                Optional<String> foundMemberCode = IndicSearchCommon.getRowValue(lineList, "MEMBER_CODE");
+
+                if (foundMemberCode.isPresent() && !foundMemberCode.get().startsWith(memberCode)) {
+                    continue;
+                }
+
+                aggregatedFileWriter.write(accountLine);
+                aggregatedFileWriter.newLine();
+                rowCounter.increment();
+
+                Optional<String> foundAccountSerialNum = IndicSearchCommon.getRowValue(lineList, "SERIAL_NUM");
+                if (foundAccountSerialNum.isEmpty()) {
+                    throw new InternalException("SERIAL_NUM was not found in line " + accountLine);
+                }
+                Long accountSerialNum = Long.parseLong(foundAccountSerialNum.get());
+
+                for (Map.Entry<String, MovableBufferedReader> entry : childTablesReadersMap.entrySet()) {
+                    String childTableName = entry.getKey();
+                    MovableBufferedReader childReader = entry.getValue();
+
+                    String childLine = childReader.getCurrentLine();
+                    if (childLine == null) {
+                        continue;
+                    }
+
+                    List<String> childLineList = Arrays.asList(childLine.split("%%%"));
+                    Optional<String> foundChildAccSerialNum = IndicSearchCommon.getRowValue(childLineList, "ACC_SERIAL_NUM");
+                    if (foundChildAccSerialNum.isEmpty()) {
+                        throw new InternalException("ACC_SERIAL_NUM was not found in table " + childTableName + " in line " + childLine);
+                    }
+                    Long childAccSerialNum = Long.parseLong(foundChildAccSerialNum.get());
+
+                    if (accountSerialNum > childAccSerialNum) {
+                        while ((childLine = childReader.nextLine()) != null) {
+                            childLineList = Arrays.asList(childLine.split("%%%"));
+                            foundChildAccSerialNum = IndicSearchCommon.getRowValue(childLineList, "ACC_SERIAL_NUM");
+                            if (foundChildAccSerialNum.isEmpty()) {
+                                throw new InternalException("ACC_SERIAL_NUM was not found in table " + childTableName + " in line " + childLine);
+                            }
+                            childAccSerialNum = Long.parseLong(foundChildAccSerialNum.get());
+
+                            if (childAccSerialNum.equals(accountSerialNum)) {
+                                aggregatedFileWriter.write(childLine);
+                                aggregatedFileWriter.newLine();
+                                rowCounter.increment();
+                            }
+
+                            if (childAccSerialNum > accountSerialNum) {
+                                break;
+                            }
+                        }
+                    } else if (accountSerialNum.equals(childAccSerialNum)) {
+                        aggregatedFileWriter.write(childLine);
+                        aggregatedFileWriter.newLine();
+                        rowCounter.increment();
+
+                        while ((childLine = childReader.nextLine()) != null) {
+                            childLineList = Arrays.asList(childLine.split("%%%"));
+                            foundChildAccSerialNum = IndicSearchCommon.getRowValue(childLineList, "ACC_SERIAL_NUM");
+                            if (foundChildAccSerialNum.isEmpty()) {
+                                throw new InternalException("ACC_SERIAL_NUM was not found in table " + childTableName + " in line " + childLine);
+                            }
+                            childAccSerialNum = Long.parseLong(foundChildAccSerialNum.get());
+
+                            if (childAccSerialNum.equals(accountSerialNum)) {
+                                aggregatedFileWriter.write(childLine);
+                                aggregatedFileWriter.newLine();
+                                rowCounter.increment();
+                            }
+
+                            if (childAccSerialNum > accountSerialNum) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            for (MovableBufferedReader br : childTablesReadersMap.values()) {
+                br.getReader().close();
+            }
+        } catch (IOException e) {
+            throw new InternalException(e);
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/aggregator/GutdfFidPassportOgrnFileAggregator.java

@@ -0,0 +1,93 @@
+package ru.nbch.indicsearchservice.aggregator;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import org.apache.commons.lang3.mutable.MutableLong;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchCommon;
+
+@Component
+public class GutdfFidPassportOgrnFileAggregator implements FileAggregator {
+    private static final List<String> REQUIRED_TABLES = List.of(
+        "RU_UID",
+        "RU_APPLICATION",
+        "RU_OBLIGPARTTAKE",
+        "RU_BANKRUPTCY",
+        "RU_SETTLED",
+        "RU_OTHERLEGAL",
+        "RU_CAPABILITY",
+        "RU_DEBT_BURDEN_INFO"
+    );
+
+    private final ApplicationSettings settings;
+    private final FileAggregatorCommon fileAggregatorCommon;
+
+    public GutdfFidPassportOgrnFileAggregator(ApplicationSettings settings,
+                                              FileAggregatorCommon fileAggregatorCommon) {
+        this.settings = settings;
+        this.fileAggregatorCommon = fileAggregatorCommon;
+    }
+
+    @Override
+    public Path aggregateFiles(UUID taskId,
+                               DataType dataType,
+                               SearchParameter searchParameter,
+                               String searchValue,
+                               String memberCode,
+                               Map<String, Path> tableFileMap,
+                               MutableLong rowCounter) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.FID || searchParameter == SearchParameter.OGRN || searchParameter == SearchParameter.PASSPORT) {
+                Path aggregatedFile = settings.getStorageDirectory().toPath().resolve("AGGREGATED-" + taskId + ".csv");
+
+                try (BufferedWriter aggregatedFileWriter = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
+                    for (String tableName : REQUIRED_TABLES) {
+                        if (tableName.equals("RU_UID")) {
+                            fileAggregatorCommon.aggregateRuUidFiles(aggregatedFileWriter, tableFileMap, memberCode, rowCounter);
+                        } else if (tableName.equals("RU_BANKRUPTCY")) {
+                            fileAggregatorCommon.aggregateBlocksTableFile(tableName, aggregatedFileWriter, tableFileMap, memberCode, rowCounter);
+                        } else {
+                            try (BufferedReader reader = Files.newBufferedReader(tableFileMap.get(tableName))) {
+                                String line;
+
+                                while ((line = reader.readLine()) != null) {
+                                    Optional<String> foundMemberCode = IndicSearchCommon.getRowValue(line, "MEMBER_CODE");
+
+                                    if (foundMemberCode.isPresent() && !foundMemberCode.get().startsWith(memberCode)) {
+                                        continue;
+                                    }
+
+                                    aggregatedFileWriter.write(line);
+                                    aggregatedFileWriter.newLine();
+                                    rowCounter.increment();
+                                }
+                            } catch (IOException e) {
+                                throw new InternalException("Failed to read file " + tableFileMap.get(tableName) + " " + e);
+                            }
+                        }
+                    }
+
+                    aggregatedFileWriter.write("EOF");
+                } catch (IOException e) {
+                    throw new InternalException(e);
+                }
+
+                return aggregatedFile;
+            }
+        }
+
+        return null;
+    }
+}

src/main/java/ru/nbch/indicsearchservice/aggregator/GutdfRuApplicationFileAggregator.java

@@ -0,0 +1,61 @@
+package ru.nbch.indicsearchservice.aggregator;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import org.apache.commons.lang3.mutable.MutableLong;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchCommon;
+
+@Component
+public class GutdfRuApplicationFileAggregator implements FileAggregator {
+    private final ApplicationSettings settings;
+
+    public GutdfRuApplicationFileAggregator(ApplicationSettings settings) {
+        this.settings = settings;
+    }
+
+    @Override
+    public Path aggregateFiles(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap, MutableLong rowCounter) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.APPLICATION_NUMBER || searchParameter == SearchParameter.OLD_APP_NUM) {
+                Path aggregatedFile = settings.getStorageDirectory().toPath().resolve("AGGREGATED-" + taskId + ".csv");
+
+                try (BufferedWriter aggregatedFileWriter = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND);
+                     BufferedReader reader = Files.newBufferedReader(tableFileMap.get("RU_APPLICATION"))) {
+                    String line;
+
+                    while ((line = reader.readLine()) != null) {
+                        Optional<String> foundMemberCode = IndicSearchCommon.getRowValue(line, "MEMBER_CODE");
+
+                        if (foundMemberCode.isPresent() && !foundMemberCode.get().startsWith(memberCode)) {
+                            continue;
+                        }
+
+                        aggregatedFileWriter.write(line);
+                        aggregatedFileWriter.newLine();
+                        rowCounter.increment();
+                    }
+
+                    aggregatedFileWriter.write("EOF");
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read file " + tableFileMap.get("RU_APPLICATION") + " " + e);
+                }
+
+                return aggregatedFile;
+            }
+        }
+
+        return null;
+    }
+}

src/main/java/ru/nbch/indicsearchservice/aggregator/GutdfRuUidFileAggregator.java

@@ -0,0 +1,48 @@
+package ru.nbch.indicsearchservice.aggregator;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.Map;
+import java.util.UUID;
+import org.apache.commons.lang3.mutable.MutableLong;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+
+@Component
+public class GutdfRuUidFileAggregator implements FileAggregator {
+    private final ApplicationSettings settings;
+    private final FileAggregatorCommon fileAggregatorCommon;
+
+    public GutdfRuUidFileAggregator(ApplicationSettings settings,
+                                    FileAggregatorCommon fileAggregatorCommon) {
+        this.settings = settings;
+        this.fileAggregatorCommon = fileAggregatorCommon;
+    }
+
+    @Override
+    public Path aggregateFiles(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap, MutableLong rowCounter) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.UUID || searchParameter == SearchParameter.ACCT_NUM) {
+                Path aggregatedFile = settings.getStorageDirectory().toPath().resolve("AGGREGATED-" + taskId + ".csv");
+
+                try (BufferedWriter aggregatedFileWriter = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
+                    fileAggregatorCommon.aggregateRuUidFiles(aggregatedFileWriter, tableFileMap, memberCode, rowCounter);
+
+                    aggregatedFileWriter.write("EOF");
+                } catch (IOException e) {
+                    throw new InternalException("Failed to write file " + aggregatedFile + " " + e);
+                }
+
+                return aggregatedFile;
+            }
+        }
+
+        return null;
+    }
+}

src/main/java/ru/nbch/indicsearchservice/aggregator/TutdfAccountFileAggregator.java

@@ -0,0 +1,48 @@
+package ru.nbch.indicsearchservice.aggregator;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.Map;
+import java.util.UUID;
+import org.apache.commons.lang3.mutable.MutableLong;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+
+@Component
+public class TutdfAccountFileAggregator implements FileAggregator {
+    private final ApplicationSettings settings;
+    private final FileAggregatorCommon fileAggregatorCommon;
+
+    public TutdfAccountFileAggregator(ApplicationSettings settings,
+                                      FileAggregatorCommon fileAggregatorCommon) {
+        this.settings = settings;
+        this.fileAggregatorCommon = fileAggregatorCommon;
+    }
+
+    @Override
+    public Path aggregateFiles(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap, MutableLong rowCounter) {
+        if (dataType == DataType.TUTDF) {
+            if (searchParameter == SearchParameter.UUID || searchParameter == SearchParameter.ACCT_NUM || searchParameter == SearchParameter.SERIAL_NUM_ACCT) {
+                Path aggregatedFile = settings.getStorageDirectory().toPath().resolve("AGGREGATED-" + taskId + ".csv");
+
+                try (BufferedWriter aggregatedFileWriter = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
+                    fileAggregatorCommon.aggregateAccountFiles(aggregatedFileWriter, tableFileMap, memberCode, rowCounter);
+
+                    aggregatedFileWriter.write("EOF");
+                } catch (IOException e) {
+                    throw new InternalException("Failed to write file " + aggregatedFile + " " + e);
+                }
+
+                return aggregatedFile;
+            }
+        }
+
+        return null;
+    }
+}

src/main/java/ru/nbch/indicsearchservice/aggregator/TutdfFidPassportOgrnFileAggregator.java

@@ -0,0 +1,88 @@
+package ru.nbch.indicsearchservice.aggregator;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import org.apache.commons.lang3.mutable.MutableLong;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchCommon;
+
+@Component
+public class TutdfFidPassportOgrnFileAggregator implements FileAggregator {
+    private static final List<String> REQUIRED_TABLES = List.of(
+        "ACCOUNT",
+        "INFORMATION",
+        "BANKRUPTCY",
+        "CONSUMER_BANKRUPTCY",
+        "LEGAL"
+    );
+
+    private final ApplicationSettings settings;
+    private final FileAggregatorCommon fileAggregatorCommon;
+
+    public TutdfFidPassportOgrnFileAggregator(ApplicationSettings settings,
+                                              FileAggregatorCommon fileAggregatorCommon) {
+        this.settings = settings;
+        this.fileAggregatorCommon = fileAggregatorCommon;
+    }
+
+    @Override
+    public Path aggregateFiles(UUID taskId,
+                               DataType dataType,
+                               SearchParameter searchParameter,
+                               String searchValue,
+                               String memberCode,
+                               Map<String, Path> tableFileMap,
+                               MutableLong rowCounter) {
+        if (dataType == DataType.TUTDF) {
+            if (searchParameter == SearchParameter.FID || searchParameter == SearchParameter.OGRN || searchParameter == SearchParameter.PASSPORT) {
+                Path aggregatedFile = settings.getStorageDirectory().toPath().resolve("AGGREGATED-" + taskId + ".csv");
+
+                try (BufferedWriter aggregatedFileWriter = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
+                    for (String tableName : REQUIRED_TABLES) {
+                        if (tableName.equals("ACCOUNT")) {
+                            fileAggregatorCommon.aggregateAccountFiles(aggregatedFileWriter, tableFileMap, memberCode, rowCounter);
+                        } else {
+                            try (BufferedReader reader = Files.newBufferedReader(tableFileMap.get(tableName))) {
+                                String line;
+
+                                while ((line = reader.readLine()) != null) {
+                                    Optional<String> foundMemberCode = IndicSearchCommon.getRowValue(line, "MEMBER_CODE");
+
+                                    if (foundMemberCode.isPresent() && !foundMemberCode.get().startsWith(memberCode)) {
+                                        continue;
+                                    }
+
+                                    aggregatedFileWriter.write(line);
+                                    aggregatedFileWriter.newLine();
+                                    rowCounter.increment();
+                                }
+                            } catch (IOException e) {
+                                throw new InternalException("Failed to read file " + tableFileMap.get(tableName) + " " + e);
+                            }
+                        }
+                    }
+
+                    aggregatedFileWriter.write("EOF");
+                } catch (IOException e) {
+                    throw new InternalException("Failed to write file " + aggregatedFile + " " + e);
+                }
+
+                return aggregatedFile;
+            }
+        }
+
+        return null;
+    }
+}

src/main/java/ru/nbch/indicsearchservice/aggregator/TutdfInformationFileAggregator.java

@@ -0,0 +1,61 @@
+package ru.nbch.indicsearchservice.aggregator;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import org.apache.commons.lang3.mutable.MutableLong;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchCommon;
+
+@Component
+public class TutdfInformationFileAggregator implements FileAggregator {
+    private final ApplicationSettings settings;
+
+    public TutdfInformationFileAggregator(ApplicationSettings settings) {
+        this.settings = settings;
+    }
+
+    @Override
+    public Path aggregateFiles(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap, MutableLong rowCounter) {
+        if (dataType == DataType.TUTDF) {
+            if (searchParameter == SearchParameter.OLD_APP_NUM || searchParameter == SearchParameter.SERIAL_NUM_APP) {
+                Path aggregatedFile = settings.getStorageDirectory().toPath().resolve("AGGREGATED-" + taskId + ".csv");
+
+                try (BufferedWriter aggregatedFileWriter = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND);
+                     BufferedReader reader = Files.newBufferedReader(tableFileMap.get("INFORMATION"))) {
+                    String line;
+
+                    while ((line = reader.readLine()) != null) {
+                        Optional<String> foundMemberCode = IndicSearchCommon.getRowValue(line, "MEMBER_CODE");
+
+                        if (foundMemberCode.isPresent() && !foundMemberCode.get().startsWith(memberCode)) {
+                            continue;
+                        }
+
+                        aggregatedFileWriter.write(line);
+                        aggregatedFileWriter.newLine();
+                        rowCounter.increment();
+                    }
+
+                    aggregatedFileWriter.write("EOF");
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read file " + tableFileMap.get("INFORMATION") + " " + e);
+                }
+
+                return aggregatedFile;
+            }
+        }
+
+        return null;
+    }
+}

src/main/java/ru/nbch/indicsearchservice/config/IndicSearchConfig.java

@@ -0,0 +1,26 @@
+package ru.nbch.indicsearchservice.config;
+
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import ru.nbch.indicsearchservice.model.SearchJob;
+
+@Configuration
+public class IndicSearchConfig {
+    private final ExecutorService searchJobExecutor = Executors.newFixedThreadPool(5);
+    private final Map<UUID, SearchJob> searchJobs = new ConcurrentHashMap<>();
+
+    @Bean("searchJobExecutor")
+    public ExecutorService searchJobExecutor() {
+        return searchJobExecutor;
+    }
+
+    @Bean("searchJobsMap")
+    public Map<UUID, SearchJob> searchJobsMap() {
+        return searchJobs;
+    }
+}

src/main/java/ru/nbch/indicsearchservice/config/ObjectMapperConfig.java

@@ -6,14 +6,13 @@ import org.springframework.context.annotation.Configuration;
 import tools.jackson.core.StreamReadConstraints;
 import tools.jackson.core.json.JsonFactory;
 import tools.jackson.databind.MapperFeature;
-import tools.jackson.databind.ObjectMapper;
 import tools.jackson.databind.PropertyNamingStrategies;
 import tools.jackson.databind.json.JsonMapper;
 
 @Configuration
 public class ObjectMapperConfig {
     @Bean
-    public ObjectMapper objectMapper() {
+    public JsonMapper objectMapper() {
         JsonFactory factory = JsonFactory.builder()
             .streamReadConstraints(StreamReadConstraints.builder()
                 .maxStringLength(100_000_000)

src/main/java/ru/nbch/indicsearchservice/config/settings/ApplicationSettings.java

@@ -5,6 +5,7 @@ import java.nio.file.Path;
 import org.springframework.boot.context.properties.ConfigurationProperties;
 import org.springframework.boot.context.properties.NestedConfigurationProperty;
 import org.springframework.context.annotation.Configuration;
+import ru.nbch.indicsearchservice.config.settings.cron.JobCleanerSettings;
 
 @Configuration
 @ConfigurationProperties(prefix = "app")
@@ -13,9 +14,11 @@ public class ApplicationSettings {
     private DataSourceSettings dataSource;
 
     private DataSourceSettings indicDataSource = new DataSourceSettings();
-
     private File storageDirectory = Path.of("/opt/app/indic-search-service-storage").toAbsolutePath().toFile();
 
+    @NestedConfigurationProperty
+    private JobCleanerSettings jobCleaner = new JobCleanerSettings();
+
     public DataSourceSettings getDataSource() {
         return dataSource;
     }
@@ -39,4 +42,12 @@ public class ApplicationSettings {
     public void setStorageDirectory(File storageDirectory) {
         this.storageDirectory = storageDirectory;
     }
+
+    public JobCleanerSettings getJobCleaner() {
+        return jobCleaner;
+    }
+
+    public void setJobCleaner(JobCleanerSettings jobCleaner) {
+        this.jobCleaner = jobCleaner;
+    }
 }

src/main/java/ru/nbch/indicsearchservice/config/settings/cron/JobCleanerSettings.java

@@ -0,0 +1,22 @@
+package ru.nbch.indicsearchservice.config.settings.cron;
+
+public class JobCleanerSettings {
+    private boolean enabled = true;
+    private String cron;
+
+    public boolean isEnabled() {
+        return enabled;
+    }
+
+    public void setEnabled(boolean enabled) {
+        this.enabled = enabled;
+    }
+
+    public String getCron() {
+        return cron;
+    }
+
+    public void setCron(String cron) {
+        this.cron = cron;
+    }
+}

src/main/java/ru/nbch/indicsearchservice/controller/IndicSearchController.java

@@ -7,6 +7,7 @@ import io.swagger.v3.oas.annotations.responses.ApiResponse;
 import io.swagger.v3.oas.annotations.responses.ApiResponses;
 import jakarta.validation.Valid;
 import java.util.Optional;
+import java.util.UUID;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.validation.FieldError;
@@ -24,6 +25,7 @@ import ru.nbch.indicsearchservice.dto.request.AddSearchJobRequestDto;
 import ru.nbch.indicsearchservice.dto.response.AddSearchJobResponseDto;
 import ru.nbch.indicsearchservice.dto.response.JobStatusResponseDto;
 import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.enums.ExportType;
 import ru.nbch.indicsearchservice.service.IndicSearchService;
 import ru.nbch.indicsearchservice.service.SettingsService;
 
@@ -63,7 +65,7 @@ public class IndicSearchController {
             description = "Success")
     })
     @GetMapping("/job_status/{id}")
-    public JobStatusResponseDto getJobStatus(@PathVariable("id") Long id) {
+    public JobStatusResponseDto getJobStatus(@PathVariable("id") UUID id) {
         return indicSearchService.getJobStatus(id);
     }
 
@@ -77,8 +79,8 @@ public class IndicSearchController {
             description = "Success")
     })
     @GetMapping("/export/{id}")
-    public ResponseEntity<?> export(@PathVariable("id") Long id,
-                                    @RequestParam(name = "type", defaultValue = "JSON") String exportType) {
+    public ResponseEntity<?> export(@PathVariable("id") UUID id,
+                                    @RequestParam(name = "type", defaultValue = "JSON") ExportType exportType) {
         return indicSearchService.export(id, exportType);
     }
 

src/main/java/ru/nbch/indicsearchservice/cron/CronChangeListener.java

@@ -0,0 +1,19 @@
+package ru.nbch.indicsearchservice.cron;
+
+import org.springframework.context.event.EventListener;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.event.CronChangedEvent;
+
+@Component
+public class CronChangeListener {
+    private final CronJobManager cronJobManager;
+
+    public CronChangeListener(CronJobManager cronJobManager) {
+        this.cronJobManager = cronJobManager;
+    }
+
+    @EventListener
+    public void onCronChanged(CronChangedEvent event) {
+        cronJobManager.rescheduleNow(event.jobName(), event.newCron());
+    }
+}

src/main/java/ru/nbch/indicsearchservice/cron/CronJob.java

@@ -0,0 +1,5 @@
+package ru.nbch.indicsearchservice.cron;
+
+public interface CronJob {
+    CronJobName getCronJobName();
+}

src/main/java/ru/nbch/indicsearchservice/cron/CronJobManager.java

@@ -0,0 +1,78 @@
+package ru.nbch.indicsearchservice.cron;
+
+import jakarta.annotation.PostConstruct;
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ScheduledFuture;
+import java.util.function.Supplier;
+import org.springframework.scheduling.TaskScheduler;
+import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.scheduling.support.CronTrigger;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.service.SettingsService;
+
+@Component
+@EnableScheduling
+public class CronJobManager {
+    private final TaskScheduler taskScheduler;
+    private final ApplicationSettings settings;
+    private final List<CronJob> cronJobs;
+    private final SettingsService settingsService;
+
+    private final Map<CronJobName, Runnable> tasks = new ConcurrentHashMap<>();
+    private final Map<CronJobName, ScheduledFuture<?>> futures = new ConcurrentHashMap<>();
+
+    public CronJobManager(TaskScheduler taskScheduler,
+                          ApplicationSettings settings,
+                          List<CronJob> cronJobs,
+                          SettingsService settingsService) {
+        this.taskScheduler = taskScheduler;
+        this.settings = settings;
+        this.cronJobs = cronJobs;
+        this.settingsService = settingsService;
+
+        for (CronJob cronJob : cronJobs) {
+            if (cronJob instanceof Runnable runnableCronJob) {
+                tasks.put(cronJob.getCronJobName(), runnableCronJob);
+            }
+        }
+    }
+
+    @PostConstruct
+    public void scheduleAll() {
+        for (CronJob cronJob : cronJobs) {
+            if (cronJob instanceof Runnable) {
+                if (cronJob instanceof JobCleaner) {
+                    Optional<String> cron = settingsService.getOptionalSettingsValueByName("jobCleaner.cron");
+                    if (cron.isPresent()) {
+                        settings.getJobCleaner().setCron(cron.get());
+                        schedule(cronJob.getCronJobName(), cron::get);
+                    }
+                } else {
+                    return;
+                }
+            }
+        }
+    }
+
+    private void schedule(CronJobName jobName, Supplier<String> cronSupplier) {
+        Runnable task = tasks.get(jobName);
+        CronTrigger trigger = new CronTrigger(cronSupplier.get());
+        ScheduledFuture<?> f = taskScheduler.schedule(task, trigger);
+        futures.put(jobName, f);
+    }
+
+    public void rescheduleNow(CronJobName jobName, String newCron) {
+        ScheduledFuture<?> f = futures.get(jobName);
+        if (f != null) {
+            f.cancel(false);
+        }
+        CronTrigger trigger = CronTrigger.resumeLenientExecution(newCron, Instant.now());
+        ScheduledFuture<?> nf = taskScheduler.schedule(tasks.get(jobName), trigger);
+        futures.put(jobName, nf);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/cron/CronJobName.java

@@ -0,0 +1,5 @@
+package ru.nbch.indicsearchservice.cron;
+
+public enum CronJobName {
+    JOB_CLEANER
+}

src/main/java/ru/nbch/indicsearchservice/cron/JobCleaner.java

@@ -0,0 +1,102 @@
+package ru.nbch.indicsearchservice.cron;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.time.LocalDateTime;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import org.apache.commons.io.FilenameUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.SearchJob;
+import ru.nbch.indicsearchservice.service.SettingsService;
+
+@Component
+public class JobCleaner implements Runnable, CronJob {
+    private static final Logger log = LoggerFactory.getLogger(JobCleaner.class);
+
+    private final ApplicationSettings settings;
+    private final Map<UUID, SearchJob> searchJobs;
+
+    public JobCleaner(ApplicationSettings settings,
+                      SettingsService settingsService,
+                      @Qualifier("searchJobsMap") Map<UUID, SearchJob> searchJobs) {
+        this.settings = settings;
+        this.searchJobs = searchJobs;
+
+        Optional<String> enabled = settingsService.getOptionalSettingsValueByName("jobCleaner.enabled");
+        if (enabled.isPresent()) {
+            settings.getJobCleaner().setEnabled(Boolean.parseBoolean(enabled.get()));
+        } else {
+            log.warn("There is no jobCleaner.enabled in SETTINGS table!");
+        }
+    }
+
+    @Override
+    public void run() {
+        if (!settings.getJobCleaner().isEnabled()) {
+            log.debug("Job cleaning disabled");
+            return;
+        }
+
+        LocalDateTime hourBefore = LocalDateTime.now().minusHours(1);
+
+        // Очищаем Map
+        Iterator<Map.Entry<UUID, SearchJob>> iterator = searchJobs.entrySet().iterator();
+        while (iterator.hasNext()) {
+            Map.Entry<UUID, SearchJob> entry = iterator.next();
+            SearchJob searchJob = entry.getValue();
+
+            if (searchJob.getFinishedAt().isBefore(hourBefore)) {
+                iterator.remove();
+            }
+        }
+
+        // Очищаем папку
+        for (File file : Optional.ofNullable(settings.getStorageDirectory().listFiles()).orElse(new File[0])) {
+            String fileNameWithoutExtension = FilenameUtils.getBaseName(file.getName());
+            String fileExtension = FilenameUtils.getExtension(file.getName());
+
+            UUID parsedUuid = null;
+            if (fileNameWithoutExtension.startsWith("AGGREGATED-")) {
+                try {
+                    parsedUuid = UUID.fromString(fileNameWithoutExtension.replace("AGGREGATED-", ""));
+                } catch (Exception e) {
+                    log.warn("Could not parse UUID from file name: {}, removing", fileNameWithoutExtension, e);
+                }
+            } else if (fileExtension.startsWith("json") || fileExtension.startsWith("xlsx")) {
+                try {
+                    parsedUuid = UUID.fromString(fileNameWithoutExtension);
+                } catch (Exception e) {
+                    log.warn("Could not parse UUID from file name: {}, removing", fileNameWithoutExtension, e);
+                }
+            } else {
+                try {
+                    parsedUuid = UUID.fromString(fileNameWithoutExtension.substring(fileNameWithoutExtension.lastIndexOf('_') + 1));
+                } catch (Exception e) {
+                    log.warn("Could not parse UUID from file name: {}, removing", fileNameWithoutExtension, e);
+                }
+            }
+
+            if (parsedUuid == null || !searchJobs.containsKey(parsedUuid)) {
+                try {
+                    Files.deleteIfExists(file.toPath());
+                } catch (IOException e) {
+                    throw new InternalException("Failed to delete file " + file + " " + e);
+                }
+            }
+        }
+    }
+
+    @Override
+    public CronJobName getCronJobName() {
+        return CronJobName.JOB_CLEANER;
+    }
+}

src/main/java/ru/nbch/indicsearchservice/dto/response/AddSearchJobResponseDto.java

@@ -3,25 +3,26 @@ package ru.nbch.indicsearchservice.dto.response;
 import io.swagger.v3.oas.annotations.media.Schema;
 import jakarta.validation.constraints.NotNull;
 import java.util.Objects;
+import java.util.UUID;
 
 @Schema(description = "Add search job response data transfer object")
 public class AddSearchJobResponseDto {
-    @Schema(description = "Job id", example = "1")
+    @Schema(description = "Job id", example = "63e6dcb5-c5bd-4ce6-adb1-947ef2a2f22c")
     @NotNull
-    private Long jobId;
+    private UUID jobId;
 
     public AddSearchJobResponseDto() {
     }
 
-    public AddSearchJobResponseDto(Long jobId) {
+    public AddSearchJobResponseDto(UUID jobId) {
         this.jobId = jobId;
     }
 
-    public Long getJobId() {
+    public UUID getJobId() {
         return jobId;
     }
 
-    public void setJobId(Long jobId) {
+    public void setJobId(UUID jobId) {
         this.jobId = jobId;
     }
 

src/main/java/ru/nbch/indicsearchservice/dto/response/InternalExceptionResponseDto.java

@@ -0,0 +1,8 @@
+package ru.nbch.indicsearchservice.dto.response;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+@Schema(description = "Internal exception response data transfer object")
+public record InternalExceptionResponseDto(
+    @Schema(description = "Error message", example = "При обработке запроса произошла ошибка.") String message) {
+}

src/main/java/ru/nbch/indicsearchservice/event/CronChangedEvent.java

@@ -0,0 +1,9 @@
+package ru.nbch.indicsearchservice.event;
+
+import ru.nbch.indicsearchservice.cron.CronJobName;
+
+public record CronChangedEvent(
+    CronJobName jobName,
+    String newCron
+) {
+}

src/main/java/ru/nbch/indicsearchservice/exception/ExceptionHandlerAdvice.java

@@ -0,0 +1,24 @@
+package ru.nbch.indicsearchservice.exception;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.converter.HttpMessageNotReadableException;
+import org.springframework.web.bind.annotation.ExceptionHandler;
+import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestControllerAdvice;
+import ru.nbch.indicsearchservice.dto.response.InternalExceptionResponseDto;
+
+@RestControllerAdvice
+public class ExceptionHandlerAdvice {
+    @ExceptionHandler(InternalException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public @ResponseBody InternalExceptionResponseDto handleInternalException(InternalException ex) {
+        return ex.getInternalExceptionResponseDto();
+    }
+
+    @ExceptionHandler(HttpMessageNotReadableException.class)
+    @ResponseStatus(HttpStatus.BAD_REQUEST)
+    public @ResponseBody InternalExceptionResponseDto handleHttpMessageNotReadableException(HttpMessageNotReadableException ex) {
+        return new InternalExceptionResponseDto("Invalid JSON " + ex);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/exception/InternalException.java

@@ -1,5 +1,7 @@
 package ru.nbch.indicsearchservice.exception;
 
+import ru.nbch.indicsearchservice.dto.response.InternalExceptionResponseDto;
+
 public class InternalException extends RuntimeException {
     private final String message;
 
@@ -7,4 +9,13 @@ public class InternalException extends RuntimeException {
         super(message);
         this.message = message;
     }
+
+    public InternalException(Throwable cause) {
+        super(cause);
+        this.message = cause.getMessage();
+    }
+
+    public InternalExceptionResponseDto getInternalExceptionResponseDto() {
+        return new InternalExceptionResponseDto(this.message);
+    }
 }

src/main/java/ru/nbch/indicsearchservice/exporter/ExcelExporter.java

@@ -0,0 +1,254 @@
+package ru.nbch.indicsearchservice.exporter;
+
+import jakarta.annotation.Nullable;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import java.util.stream.Collectors;
+import org.apache.commons.lang3.mutable.MutableLong;
+import org.apache.commons.lang3.tuple.Pair;
+import org.apache.poi.ss.usermodel.BorderStyle;
+import org.apache.poi.ss.usermodel.Cell;
+import org.apache.poi.ss.usermodel.CellStyle;
+import org.apache.poi.ss.usermodel.Row;
+import org.apache.poi.ss.usermodel.Sheet;
+import org.apache.poi.ss.usermodel.VerticalAlignment;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.apache.poi.ss.util.CellRangeAddress;
+import org.apache.poi.xssf.streaming.SXSSFWorkbook;
+import org.apache.poi.xssf.usermodel.XSSFFont;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+
+@Component
+public class ExcelExporter implements Exporter {
+    private static final Logger log = LoggerFactory.getLogger(ExcelExporter.class);
+    private static final Long EXCEL_SHEET_MAX_SIZE = 1_048_575L;
+
+    private final ApplicationSettings settings;
+
+    public ExcelExporter(ApplicationSettings settings) {
+        this.settings = settings;
+    }
+
+    public Path writeExcelFile(@Nullable Path aggregatedFile, UUID taskId, Long totalRows, Map<String, TableMetaData> tableMetaDataMap) {
+        if (aggregatedFile == null) {
+            return null;
+        }
+
+        Path excelFile = settings.getStorageDirectory().toPath().resolve(taskId.toString() + ".xlsx");
+
+        try (OutputStream os = Files.newOutputStream(excelFile);
+             BufferedReader aggregatedFileReader = Files.newBufferedReader(aggregatedFile);
+             SXSSFWorkbook workbook = new SXSSFWorkbook()) {
+            CellStyle headerCellStyle = createHeaderCellStyle(workbook);
+            CellStyle cellStyle = createCellStyle(workbook);
+
+            Iterator<String> iterator = aggregatedFileReader.lines().iterator();
+
+            MutableLong sheetRowCounter = new MutableLong(0L);
+            MutableLong sheetTableCounter = new MutableLong(1L);
+
+            long count = 0L;
+
+            boolean isFirst = true;
+            String lastTableName;
+            List<String> rows = new ArrayList<>();
+            while (iterator.hasNext()) {
+                String line = iterator.next();
+                List<String> lineList = Arrays.asList(line.split("%%%"));
+
+                log.info("Processing row: {} / {}", count++, totalRows);
+
+                if (!isFirst && (FIRST_LEVEL_TABLES.contains(lineList.getFirst()) || line.equals("EOF"))) {
+                    lastTableName = rows.getFirst().split("%%%")[0];
+                    writeToExcel(workbook, rows, sheetRowCounter, sheetTableCounter, headerCellStyle, cellStyle, tableMetaDataMap);
+                    if (lastTableName != null && !lastTableName.equals(lineList.getFirst())) {
+                        sheetRowCounter.setValue(0L);
+                        sheetTableCounter.setValue(1L);
+                    }
+                    rows.clear();
+                }
+
+                rows.add(line);
+                isFirst = false;
+            }
+
+            workbook.write(os);
+        } catch (IOException e) {
+            log.error(e.getMessage(), e);
+        }
+
+        return excelFile;
+    }
+
+    private void writeToExcel(Workbook workbook,
+                              List<String> rows,
+                              MutableLong sheetRowCounter,
+                              MutableLong sheetTableCounter,
+                              CellStyle headerCellStyle,
+                              CellStyle cellStyle,
+                              Map<String, TableMetaData> tableMetaDataMap) {
+        if (rows == null || rows.isEmpty()) {
+            return;
+        }
+
+        String parentTableName = rows.getFirst().split("%%%")[0];
+
+        Sheet tableSheet;
+        int rowsApproximateSize = rows.stream().mapToInt(r -> r.split("%%%", -1).length).sum();
+        if (sheetRowCounter.longValue() + (rowsApproximateSize * 2L) >= EXCEL_SHEET_MAX_SIZE) {
+            tableSheet = createSheet(workbook, parentTableName.toUpperCase() + "_" + sheetTableCounter.incrementAndGet());
+            sheetRowCounter.setValue(0L);
+        } else {
+            tableSheet = createSheet(workbook, parentTableName.toUpperCase());
+        }
+
+        for (String row : rows) {
+            List<String> rowList = Arrays.asList(row.split("%%%", -1));
+            String tableName = rowList.getFirst();
+
+            TableMetaData rowMetaData = tableMetaDataMap.get(tableName);
+
+            Set<String> allowedFields = new HashSet<>();
+            if (rowMetaData != null && rowMetaData.getFieldMetaData() != null) {
+                allowedFields = rowMetaData.getFieldMetaData().keySet().stream()
+                    .map(String::toUpperCase)
+                    .collect(Collectors.toSet());
+            }
+
+            List<String> rowSublist = rowList.subList(1, rowList.size());
+            Map<String, Pair<String, String>> rowValues = new LinkedHashMap<>();
+            for (int i = 0; i + 1 <= rowSublist.size(); i = i + 2) {
+                String columnName = rowSublist.get(i);
+                String columnValue = rowSublist.get(i + 1);
+
+                if (columnName != null && allowedFields.contains(columnName.toUpperCase())) {
+                    rowValues.put(columnName, Pair.of(rowMetaData.getFieldMetaData().get(columnName).getFieldLocalization(), columnValue));
+                }
+            }
+
+            createHeaderRow(
+                rowMetaData != null ? rowMetaData.getTableNameLocalization() : tableName,
+                tableSheet,
+                sheetRowCounter,
+                headerCellStyle
+            );
+
+            for (Map.Entry<String, Pair<String, String>> entry : rowValues.entrySet()) {
+                String columnName = entry.getKey();
+                String columnLocalization = entry.getValue().getLeft();
+                String columnValue = entry.getValue().getRight();
+
+                writeFieldDataIntoSheetRow(
+                    columnName,
+                    columnLocalization,
+                    columnValue,
+                    tableSheet,
+                    sheetRowCounter,
+                    cellStyle
+                );
+            }
+
+            sheetRowCounter.increment();
+        }
+    }
+
+    private CellStyle createHeaderCellStyle(Workbook workbook) {
+        CellStyle headerCellStyle = workbook.createCellStyle();
+        headerCellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
+
+        XSSFFont font = (XSSFFont) workbook.createFont();
+        font.setFontName("SansSerif");
+        font.setFontHeightInPoints((short) 11);
+        font.setBold(true);
+        headerCellStyle.setFont(font);
+
+        return headerCellStyle;
+    }
+
+    private CellStyle createCellStyle(Workbook workbook) {
+        CellStyle cellStyle = workbook.createCellStyle();
+        cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
+        cellStyle.setBorderBottom(BorderStyle.THIN);
+        cellStyle.setBorderLeft(BorderStyle.THIN);
+        cellStyle.setBorderTop(BorderStyle.THIN);
+        cellStyle.setBorderRight(BorderStyle.THIN);
+
+        XSSFFont font = (XSSFFont) workbook.createFont();
+        font.setFontName("Calibri");
+        font.setFontHeightInPoints((short) 11);
+        cellStyle.setFont(font);
+
+        return cellStyle;
+    }
+
+    private Sheet createSheet(Workbook workbook, String sheetName) {
+        Sheet foundSheet = workbook.getSheet(sheetName);
+
+        if (foundSheet == null) {
+            Sheet sheet = workbook.createSheet(sheetName);
+            sheet.setColumnWidth(0, 25 * 256);
+            sheet.setColumnWidth(1, 115 * 256);
+            sheet.setColumnWidth(2, 38 * 256);
+
+            return sheet;
+        }
+
+        return foundSheet;
+    }
+
+    private void createHeaderRow(String localizedTableName,
+                                 Sheet sheet,
+                                 MutableLong currentRow,
+                                 CellStyle headerCellStyle) {
+        Row headerRow = sheet.createRow(currentRow.intValue());
+        headerRow.setHeightInPoints(15);
+
+        Cell headerCell = headerRow.createCell(0);
+        headerCell.setCellValue(localizedTableName);
+        headerCell.setCellStyle(headerCellStyle);
+        sheet.addMergedRegion(new CellRangeAddress(currentRow.intValue(), currentRow.intValue(), 0, 2));
+
+        currentRow.increment();
+    }
+
+    private void writeFieldDataIntoSheetRow(String fieldKey,
+                                            String localizedFieldKey,
+                                            @Nullable Object fieldValue,
+                                            Sheet sheet,
+                                            MutableLong currentRow,
+                                            CellStyle cellStyle) {
+        Row dataRow = sheet.createRow(currentRow.intValue());
+        dataRow.setHeightInPoints(15);
+
+        Cell dataFieldCell = dataRow.createCell(0);
+        dataFieldCell.setCellValue(fieldKey.toUpperCase());
+        dataFieldCell.setCellStyle(cellStyle);
+
+        Cell descriptionCell = dataRow.createCell(1);
+        descriptionCell.setCellValue(localizedFieldKey);
+        descriptionCell.setCellStyle(cellStyle);
+
+        Cell dataValueCell = dataRow.createCell(2);
+        dataValueCell.setCellValue(Optional.ofNullable(fieldValue).orElse("").toString());
+        dataValueCell.setCellStyle(cellStyle);
+
+        currentRow.increment();
+    }
+}

src/main/java/ru/nbch/indicsearchservice/exporter/Exporter.java

@@ -0,0 +1,21 @@
+package ru.nbch.indicsearchservice.exporter;
+
+import java.util.Set;
+
+public interface Exporter {
+    Set<String> FIRST_LEVEL_TABLES = Set.of(
+        "RU_UID",
+        "RU_APPLICATION",
+        "RU_OBLIGPARTTAKE",
+        "RU_BANKRUPTCY",
+        "RU_SETTLED",
+        "RU_OTHERLEGAL",
+        "RU_CAPABILITY",
+        "RU_DEBT_BURDEN_INFO",
+        "ACCOUNT",
+        "INFORMATION",
+        "BANKRUPTCY",
+        "CONSUMER_BANKRUPTCY",
+        "LEGAL"
+    );
+}

src/main/java/ru/nbch/indicsearchservice/exporter/JsonExporter.java

@@ -0,0 +1,178 @@
+package ru.nbch.indicsearchservice.exporter;
+
+import jakarta.annotation.Nullable;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.model.TableData;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import tools.jackson.core.JsonGenerator;
+import tools.jackson.databind.json.JsonMapper;
+
+@Component
+public class JsonExporter implements Exporter {
+    private static final Logger log = LoggerFactory.getLogger(JsonExporter.class);
+
+    private final ApplicationSettings settings;
+    private final JsonMapper jsonMapper;
+
+    public JsonExporter(ApplicationSettings settings,
+                        JsonMapper jsonMapper) {
+        this.settings = settings;
+        this.jsonMapper = jsonMapper;
+    }
+
+    public Path writeJsonFile(@Nullable Path aggregatedFile,
+                              UUID taskId,
+                              SearchParameter searchParameter,
+                              Map<String, TableMetaData> tableMetaDataMap) {
+        if (aggregatedFile == null) {
+            return null;
+        }
+
+        boolean isPassportOgrnFid = searchParameter == SearchParameter.PASSPORT ||
+            searchParameter == SearchParameter.OGRN ||
+            searchParameter == SearchParameter.FID;
+
+        Path jsonFile = settings.getStorageDirectory().toPath().resolve(taskId.toString() + ".json");
+
+        try (BufferedReader reader = Files.newBufferedReader(aggregatedFile);
+             JsonGenerator jsonGenerator = jsonMapper.createGenerator(Files.newOutputStream(jsonFile))) {
+            jsonGenerator.writeStartObject();
+            jsonGenerator.writeName("datasheets");
+            jsonGenerator.writeStartArray();
+
+            Iterator<String> iterator = reader.lines().iterator();
+            List<String> rows = new ArrayList<>();
+            boolean isFirst = true;
+            boolean isFirstArray = true;
+            boolean isFileEmpty = true;
+
+            AtomicReference<Integer> previousFid = new AtomicReference<>();
+            while (iterator.hasNext()) {
+                String line = iterator.next();
+
+                if (line == null || line.trim().isEmpty()) {
+                    continue;
+                }
+
+                List<String> lineList = Arrays.asList(line.split("%%%", -1));
+                String tableName = lineList.getFirst();
+
+                if (!isFirst && (FIRST_LEVEL_TABLES.contains(tableName) || line.equals("EOF"))) {
+                    TableData parentData = buildTableDataHierarchy(rows, tableMetaDataMap);
+                    if (parentData != null) {
+                        if (isPassportOgrnFid) {
+                            Object currentFidField = parentData.getFieldData().stream()
+                                .filter(fd -> fd.columnName().equals("FID") && fd.columnValue() != null)
+                                .findFirst()
+                                .orElse(new TableData.FieldData("FID", null))
+                                .columnValue();
+
+                            if (previousFid.get() == null || (currentFidField != null && Integer.parseInt(currentFidField.toString()) != previousFid.get())) {
+                                previousFid.set(Integer.parseInt(currentFidField.toString()));
+                                if (!isFirstArray) {
+                                    jsonGenerator.writeEndArray();
+                                }
+                                jsonGenerator.writeStartArray();
+                                jsonMapper.writeValue(jsonGenerator, parentData);
+                                isFirstArray = false;
+                                isFileEmpty = false;
+                            } else {
+                                jsonMapper.writeValue(jsonGenerator, parentData);
+                            }
+                        } else {
+                            jsonGenerator.writeStartArray();
+                            jsonMapper.writeValue(jsonGenerator, parentData);
+                            jsonGenerator.writeEndArray();
+                        }
+                    }
+                    rows.clear();
+                }
+
+                rows.add(line);
+                isFirst = false;
+            }
+
+            if (!isPassportOgrnFid) {
+                jsonGenerator.writeEndArray(); // Закрываем массив объекта
+            } else if (!isFileEmpty) {
+                jsonGenerator.writeEndArray(); // Закрываем массивы объектов с одним FID для PASSPORT, OGRN, FID
+                jsonGenerator.writeEndArray(); // Закрываем общий массив
+            } else {
+                jsonGenerator.writeEndArray(); // Если файл пуст, закрываем только общий массив
+            }
+            jsonGenerator.writeEndObject();
+        } catch (IOException e) {
+            log.error(e.getMessage(), e);
+        }
+
+        return jsonFile;
+    }
+
+    private TableData buildTableDataHierarchy(List<String> rows, Map<String, TableMetaData> tableMetaDataMap) {
+        if (rows == null || rows.isEmpty()) {
+            return null;
+        }
+
+        TableData parentTableData = parseSingleRow(rows.getFirst(), tableMetaDataMap);
+        if (parentTableData == null) {
+            return null;
+        }
+
+        for (int i = 1; i < rows.size(); i++) {
+            TableData childTableData = parseSingleRow(rows.get(i), tableMetaDataMap);
+            if (childTableData != null) {
+                parentTableData.getRelatedTableData().add(childTableData);
+            }
+        }
+
+        return parentTableData;
+    }
+
+    private TableData parseSingleRow(String row, Map<String, TableMetaData> tableMetaDataMap) {
+        String[] parts = row.split("%%%", -1);
+
+        if (parts.length == 0 || parts[0].isEmpty()) {
+            return null;
+        }
+
+        String tableName = parts[0];
+        TableMetaData metaData = tableMetaDataMap.get(tableName);
+
+        Set<String> allowedFields = metaData != null ?
+            metaData.getFieldMetaData().keySet().stream().map(String::toUpperCase).collect(Collectors.toSet()) :
+            new HashSet<>();
+
+        List<TableData.FieldData> fieldData = new ArrayList<>();
+
+        for (int i = 1; i + 1 < parts.length; i += 2) {
+            String columnName = parts[i];
+            String columnValue = parts[i + 1];
+
+            if (columnName != null && !columnName.isEmpty()) {
+                if (allowedFields.contains(columnName.toUpperCase())) {
+                    fieldData.add(new TableData.FieldData(columnName, columnValue));
+                }
+            }
+        }
+
+        return new TableData(tableName, fieldData);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/AccountTableLoader.java

@@ -0,0 +1,143 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.loader.subtable.AccountSubTableLoader;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchCommon;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class AccountTableLoader implements FirstLevelTableLoader, TableLoaderForId {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+    private final List<AccountSubTableLoader> accountSubTableLoaders;
+
+    public AccountTableLoader(MapperHolder mapperHolder,
+                              IndicSearchUtils indicSearchUtils,
+                              List<AccountSubTableLoader> accountSubTableLoaders) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+        this.accountSubTableLoaders = accountSubTableLoaders;
+    }
+
+    @Override
+    public String getTableName() {
+        return "ACCOUNT";
+    }
+
+    @Override
+    public Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter) {
+        if (dataType == DataType.TUTDF &&
+            (searchParameter == SearchParameter.UUID ||
+                searchParameter == SearchParameter.ACCT_NUM ||
+                searchParameter == SearchParameter.SERIAL_NUM_ACCT ||
+                searchParameter == SearchParameter.FID ||
+                searchParameter == SearchParameter.PASSPORT ||
+                searchParameter == SearchParameter.OGRN)) {
+            Set<String> result = new HashSet<>();
+
+            result.add(getTableName());
+            result.addAll(accountSubTableLoaders.stream().map(TableLoader::getTableName).toList());
+
+            return result;
+        }
+
+        return Set.of();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchBy(UUID taskId,
+                         DataType dataType,
+                         SearchParameter searchParameter,
+                         String searchValue,
+                         String memberCode,
+                         Map<String, Path> tableFileMap,
+                         Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.TUTDF) {
+            if (searchParameter == SearchParameter.UUID) {
+                if (IndicSearchCommon.isCastableField(getTableName(), "UUID")) {
+                    int maxSearchValueSize = tableMetaDataMap.get(getTableName()).getFieldMetaData().get("UUID").getColumnSize();
+                    searchValue = searchValue.length() > maxSearchValueSize ? searchValue.substring(0, maxSearchValueSize) : searchValue;
+                }
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByUuidAndMemberCodeFromAccount(searchValue, memberCode)) {
+                    Set<Integer> foundFids = new HashSet<>();
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, foundFids, tableMetaDataMap));
+                    accountSubTableLoaders.parallelStream().forEach(tl -> tl.searchByAccountFid(taskId, foundFids, tableFileMap, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            } else if (searchParameter == SearchParameter.ACCT_NUM) {
+                if (IndicSearchCommon.isCastableField(getTableName(), "ACCT_NUM")) {
+                    int maxSearchValueSize = tableMetaDataMap.get(getTableName()).getFieldMetaData().get("ACCT_NUM").getColumnSize();
+                    searchValue = searchValue.length() > maxSearchValueSize ? searchValue.substring(0, maxSearchValueSize) : searchValue;
+                }
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByAcctNumAndMemberCodeFromAccount(searchValue, memberCode)) {
+                    Set<Integer> foundFids = new HashSet<>();
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, foundFids, tableMetaDataMap));
+                    accountSubTableLoaders.parallelStream().forEach(tl -> tl.searchByAccountFid(taskId, foundFids, tableFileMap, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            } else if (searchParameter == SearchParameter.SERIAL_NUM_ACCT) {
+                if (IndicSearchCommon.isCastableField(getTableName(), "SERIAL_NUM")) {
+                    int maxSearchValueSize = tableMetaDataMap.get(getTableName()).getFieldMetaData().get("SERIAL_NUM").getColumnSize();
+                    searchValue = searchValue.length() > maxSearchValueSize ? searchValue.substring(0, maxSearchValueSize) : searchValue;
+                }
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllBySerialNumAndMemberCodeFromAccount(searchValue, memberCode)) {
+                    Set<Integer> foundFids = new HashSet<>();
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, foundFids, tableMetaDataMap));
+                    accountSubTableLoaders.parallelStream().forEach(tl -> tl.searchByAccountFid(taskId, foundFids, tableFileMap, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            } else if (searchParameter == SearchParameter.FID) {
+                Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
+
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromAccount(fids)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                    accountSubTableLoaders.parallelStream().forEach(tl -> tl.searchByAccountFid(taskId, fids, tableFileMap, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId,
+                           DataType dataType,
+                           SearchParameter searchParameter,
+                           Set<Integer> fids,
+                           String memberCode,
+                           Map<String, Path> tableFileMap,
+                           Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.TUTDF) {
+            if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
+                if (!fids.isEmpty()) {
+                    try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromAccount(fids)) {
+                        tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                        accountSubTableLoaders.parallelStream().forEach(tl -> tl.searchByAccountFid(taskId, fids, tableFileMap, tableMetaDataMap));
+                    } catch (IOException e) {
+                        throw new InternalException("Failed to read cursor " + e);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/BankruptcyTableLoader.java

@@ -0,0 +1,90 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class BankruptcyTableLoader implements FirstLevelTableLoader, TableLoaderForId {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public BankruptcyTableLoader(MapperHolder mapperHolder,
+                                 IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "BANKRUPTCY";
+    }
+
+    @Override
+    public Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter) {
+        if (dataType == DataType.TUTDF &&
+            (searchParameter == SearchParameter.FID ||
+                searchParameter == SearchParameter.PASSPORT ||
+                searchParameter == SearchParameter.OGRN)) {
+            return Set.of(getTableName());
+        }
+
+        return Set.of();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchBy(UUID taskId,
+                         DataType dataType,
+                         SearchParameter searchParameter,
+                         String searchValue,
+                         String memberCode,
+                         Map<String, Path> tableFileMap,
+                         Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.TUTDF) {
+            if (searchParameter == SearchParameter.FID) {
+                Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
+
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromBankruptcy(fids)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId,
+                           DataType dataType,
+                           SearchParameter searchParameter,
+                           Set<Integer> fids,
+                           String memberCode,
+                           Map<String, Path> tableFileMap,
+                           Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.TUTDF) {
+            if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
+                if (!fids.isEmpty()) {
+                    try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromBankruptcy(fids)) {
+                        tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                    } catch (IOException e) {
+                        throw new InternalException("Failed to read cursor " + e);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/ConsumerBankruptcyTableLoader.java

@@ -0,0 +1,90 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class ConsumerBankruptcyTableLoader implements FirstLevelTableLoader, TableLoaderForId {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public ConsumerBankruptcyTableLoader(MapperHolder mapperHolder,
+                                         IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "CONSUMER_BANKRUPTCY";
+    }
+
+    @Override
+    public Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter) {
+        if (dataType == DataType.TUTDF &&
+            (searchParameter == SearchParameter.FID ||
+                searchParameter == SearchParameter.PASSPORT ||
+                searchParameter == SearchParameter.OGRN)) {
+            return Set.of(getTableName());
+        }
+
+        return Set.of();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchBy(UUID taskId,
+                         DataType dataType,
+                         SearchParameter searchParameter,
+                         String searchValue,
+                         String memberCode,
+                         Map<String, Path> tableFileMap,
+                         Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.TUTDF) {
+            if (searchParameter == SearchParameter.FID) {
+                Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
+
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromConsumerBankruptcy(fids)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId,
+                           DataType dataType,
+                           SearchParameter searchParameter,
+                           Set<Integer> fids,
+                           String memberCode,
+                           Map<String, Path> tableFileMap,
+                           Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.TUTDF) {
+            if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
+                if (!fids.isEmpty()) {
+                    try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromConsumerBankruptcy(fids)) {
+                        tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                    } catch (IOException e) {
+                        throw new InternalException("Failed to read cursor " + e);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/FirstLevelTableLoader.java

@@ -0,0 +1,21 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+
+public interface FirstLevelTableLoader extends TableLoader {
+    void searchBy(UUID taskId,
+                  DataType dataType,
+                  SearchParameter searchParameter,
+                  String searchValue,
+                  String memberCode,
+                  Map<String, Path> tableFileMap,
+                  Map<String, TableMetaData> tableMetaDataMap);
+
+    Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter);
+}

src/main/java/ru/nbch/indicsearchservice/loader/IdTableLoader.java

@@ -0,0 +1,142 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchCommon;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class IdTableLoader implements FirstLevelTableLoader {
+    private final MapperHolder mapperHolder;
+    private final List<TableLoaderForId> tableLoaders;
+
+    public IdTableLoader(MapperHolder mapperHolder,
+                         List<TableLoaderForId> tableLoaders) {
+        this.mapperHolder = mapperHolder;
+        this.tableLoaders = tableLoaders;
+    }
+
+    @Override
+    public String getTableName() {
+        return "ID";
+    }
+
+    @Override
+    public Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter) {
+        if ((dataType == DataType.GUTDF || dataType == DataType.RUTDF || dataType == DataType.TUTDF) &&
+            (searchParameter == SearchParameter.PASSPORT ||
+                searchParameter == SearchParameter.OGRN)) {
+            Set<String> result = new HashSet<>();
+
+            result.add(getTableName());
+            result.addAll(tableLoaders.stream()
+                .map(l -> l.getTableNamesIfSuitable(dataType, searchParameter))
+                .flatMap(Collection::stream)
+                .toList());
+
+            return result;
+        }
+
+        return Set.of();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchBy(UUID taskId,
+                         DataType dataType,
+                         SearchParameter searchParameter,
+                         String searchValue,
+                         String memberCode,
+                         Map<String, Path> tableFileMap,
+                         Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.OGRN || searchParameter == SearchParameter.PASSPORT) {
+                Set<Integer> foundFids = new HashSet<>();
+
+                if (IndicSearchCommon.isCastableField(getTableName(), "ID_NORM")) {
+                    int maxSearchValueSize = tableMetaDataMap.get(getTableName()).getFieldMetaData().get("ID_NORM").getColumnSize();
+                    searchValue = searchValue.length() > maxSearchValueSize ? searchValue.substring(0, maxSearchValueSize) : searchValue;
+                }
+                try (Cursor<LinkedHashMap<String, Object>> cursor = searchParameter == SearchParameter.OGRN ?
+                    mapperHolder.getIndicMapper().findFidsByOgrnFromId(searchValue) :
+                    mapperHolder.getIndicMapper().findFidsByPassportFromId(searchValue)) {
+                    for (LinkedHashMap<String, Object> row : cursor) {
+                        for (Map.Entry<String, Object> entry : row.entrySet()) {
+                            String columnName = entry.getKey();
+                            Object columnValue = entry.getValue();
+
+                            if (columnName != null && columnValue != null) {
+                                if (columnName.equals("FID")) {
+                                    foundFids.add(Integer.parseInt(columnValue.toString()));
+                                }
+                            }
+                        }
+                    }
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+
+                tableLoaders.parallelStream().forEach(tl -> tl.searchById(
+                    taskId,
+                    dataType,
+                    searchParameter,
+                    foundFids,
+                    memberCode,
+                    tableFileMap,
+                    tableMetaDataMap
+                ));
+            }
+        } else if (dataType == DataType.TUTDF) {
+            if (searchParameter == SearchParameter.OGRN || searchParameter == SearchParameter.PASSPORT) {
+                Set<Integer> foundFids = new HashSet<>();
+
+                if (IndicSearchCommon.isCastableField(getTableName(), "ID_NORM")) {
+                    int maxSearchValueSize = tableMetaDataMap.get(getTableName()).getFieldMetaData().get("ID_NORM").getColumnSize();
+                    searchValue = searchValue.length() > maxSearchValueSize ? searchValue.substring(0, maxSearchValueSize) : searchValue;
+                }
+                try (Cursor<LinkedHashMap<String, Object>> cursor = searchParameter == SearchParameter.OGRN ?
+                    mapperHolder.getIndicMapper().findFidsByOgrnFromIdForTutdf(searchValue) :
+                    mapperHolder.getIndicMapper().findFidsByPassportFromIdForTutdf(searchValue)) {
+                    for (LinkedHashMap<String, Object> row : cursor) {
+                        for (Map.Entry<String, Object> entry : row.entrySet()) {
+                            String columnName = entry.getKey();
+                            Object columnValue = entry.getValue();
+
+                            if (columnName != null && columnValue != null) {
+                                if (columnName.equals("FID")) {
+                                    foundFids.add(Integer.parseInt(columnValue.toString()));
+                                }
+                            }
+                        }
+                    }
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+
+                tableLoaders.parallelStream().forEach(tl -> tl.searchById(
+                    taskId,
+                    dataType,
+                    searchParameter,
+                    foundFids,
+                    memberCode,
+                    tableFileMap,
+                    tableMetaDataMap
+                ));
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/InformationTableLoader.java

@@ -0,0 +1,113 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchCommon;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class InformationTableLoader implements FirstLevelTableLoader, TableLoaderForId {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public InformationTableLoader(MapperHolder mapperHolder,
+                                  IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "INFORMATION";
+    }
+
+    @Override
+    public Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter) {
+        if (dataType == DataType.TUTDF &&
+            (searchParameter == SearchParameter.OLD_APP_NUM ||
+                searchParameter == SearchParameter.SERIAL_NUM_APP ||
+                searchParameter == SearchParameter.FID ||
+                searchParameter == SearchParameter.PASSPORT ||
+                searchParameter == SearchParameter.OGRN)) {
+            return Set.of(getTableName());
+        }
+
+        return Set.of();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchBy(UUID taskId,
+                         DataType dataType,
+                         SearchParameter searchParameter,
+                         String searchValue,
+                         String memberCode,
+                         Map<String, Path> tableFileMap,
+                         Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.TUTDF) {
+            if (searchParameter == SearchParameter.OLD_APP_NUM) {
+                if (IndicSearchCommon.isCastableField(getTableName(), "APP_NUM")) {
+                    int maxSearchValueSize = tableMetaDataMap.get(getTableName()).getFieldMetaData().get("APP_NUM").getColumnSize();
+                    searchValue = searchValue.length() > maxSearchValueSize ? searchValue.substring(0, maxSearchValueSize) : searchValue;
+                }
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByAppNumAndMemberCodeFromInformation(searchValue, memberCode)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            } else if (searchParameter == SearchParameter.SERIAL_NUM_APP) {
+                if (IndicSearchCommon.isCastableField(getTableName(), "SERIAL_NUM")) {
+                    int maxSearchValueSize = tableMetaDataMap.get(getTableName()).getFieldMetaData().get("SERIAL_NUM").getColumnSize();
+                    searchValue = searchValue.length() > maxSearchValueSize ? searchValue.substring(0, maxSearchValueSize) : searchValue;
+                }
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllBySerialNumAndMemberCodeFromInformation(searchValue, memberCode)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            } else if (searchParameter == SearchParameter.FID) {
+                Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
+
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromInformation(fids)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId,
+                           DataType dataType,
+                           SearchParameter searchParameter,
+                           Set<Integer> fids,
+                           String memberCode,
+                           Map<String, Path> tableFileMap,
+                           Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.TUTDF) {
+            if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
+                if (!fids.isEmpty()) {
+                    try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromInformation(fids)) {
+                        tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                    } catch (IOException e) {
+                        throw new InternalException("Failed to read cursor " + e);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/LegalTableLoader.java

@@ -0,0 +1,90 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class LegalTableLoader implements FirstLevelTableLoader, TableLoaderForId {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public LegalTableLoader(MapperHolder mapperHolder,
+                            IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "LEGAL";
+    }
+
+    @Override
+    public Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter) {
+        if (dataType == DataType.TUTDF &&
+            (searchParameter == SearchParameter.FID ||
+                searchParameter == SearchParameter.PASSPORT ||
+                searchParameter == SearchParameter.OGRN)) {
+            return Set.of(getTableName());
+        }
+
+        return Set.of();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchBy(UUID taskId,
+                         DataType dataType,
+                         SearchParameter searchParameter,
+                         String searchValue,
+                         String memberCode,
+                         Map<String, Path> tableFileMap,
+                         Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.TUTDF) {
+            if (searchParameter == SearchParameter.FID) {
+                Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
+
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromLegal(fids)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId,
+                           DataType dataType,
+                           SearchParameter searchParameter,
+                           Set<Integer> fids,
+                           String memberCode,
+                           Map<String, Path> tableFileMap,
+                           Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.TUTDF) {
+            if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
+                if (!fids.isEmpty()) {
+                    try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromLegal(fids)) {
+                        tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                    } catch (IOException e) {
+                        throw new InternalException("Failed to read cursor " + e);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuApplicationTableLoader.java

@@ -0,0 +1,113 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchCommon;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuApplicationTableLoader implements FirstLevelTableLoader, TableLoaderForId {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuApplicationTableLoader(MapperHolder mapperHolder,
+                                    IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_APPLICATION";
+    }
+
+    @Override
+    public Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter) {
+        if ((dataType == DataType.GUTDF || dataType == DataType.RUTDF) &&
+            (searchParameter == SearchParameter.APPLICATION_NUMBER ||
+                searchParameter == SearchParameter.OLD_APP_NUM ||
+                searchParameter == SearchParameter.FID ||
+                searchParameter == SearchParameter.PASSPORT ||
+                searchParameter == SearchParameter.OGRN)) {
+            return Set.of(getTableName());
+        }
+
+        return Set.of();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchBy(UUID taskId,
+                         DataType dataType,
+                         SearchParameter searchParameter,
+                         String searchValue,
+                         String memberCode,
+                         Map<String, Path> tableFileMap,
+                         Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.APPLICATION_NUMBER) {
+                if (IndicSearchCommon.isCastableField(getTableName(), "APPLICATION_NUMBER")) {
+                    int maxSearchValueSize = tableMetaDataMap.get(getTableName()).getFieldMetaData().get("APPLICATION_NUMBER").getColumnSize();
+                    searchValue = searchValue.length() > maxSearchValueSize ? searchValue.substring(0, maxSearchValueSize) : searchValue;
+                }
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByApplicationNumberAndMemberCodeFromRuApplication(searchValue, memberCode)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            } else if (searchParameter == SearchParameter.OLD_APP_NUM) {
+                if (IndicSearchCommon.isCastableField(getTableName(), "OLD_APP_NUM")) {
+                    int maxSearchValueSize = tableMetaDataMap.get(getTableName()).getFieldMetaData().get("OLD_APP_NUM").getColumnSize();
+                    searchValue = searchValue.length() > maxSearchValueSize ? searchValue.substring(0, maxSearchValueSize) : searchValue;
+                }
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByOldAppNumAndMemberCodeFromRuApplication(searchValue, memberCode)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            } else if (searchParameter == SearchParameter.FID) {
+                Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
+
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuApplication(fids)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId,
+                           DataType dataType,
+                           SearchParameter searchParameter,
+                           Set<Integer> fids,
+                           String memberCode,
+                           Map<String, Path> tableFileMap,
+                           Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
+                if (!fids.isEmpty()) {
+                    try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuApplication(fids)) {
+                        tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                    } catch (IOException e) {
+                        throw new InternalException("Failed to read cursor " + e);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuBankruptcyTableLoader.java

@@ -0,0 +1,90 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuBankruptcyTableLoader implements FirstLevelTableLoader, TableLoaderForId {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuBankruptcyTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_BANKRUPTCY";
+    }
+
+    @Override
+    public Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter) {
+        if ((dataType == DataType.GUTDF || dataType == DataType.RUTDF) &&
+            (searchParameter == SearchParameter.FID ||
+                searchParameter == SearchParameter.PASSPORT ||
+                searchParameter == SearchParameter.OGRN)) {
+            return Set.of(getTableName());
+        }
+
+        return Set.of();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchBy(UUID taskId,
+                         DataType dataType,
+                         SearchParameter searchParameter,
+                         String searchValue,
+                         String memberCode,
+                         Map<String, Path> tableFileMap,
+                         Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.FID) {
+                Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
+
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuBankruptcy(fids)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId,
+                           DataType dataType,
+                           SearchParameter searchParameter,
+                           Set<Integer> fids,
+                           String memberCode,
+                           Map<String, Path> tableFileMap,
+                           Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
+                if (!fids.isEmpty()) {
+                    try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuBankruptcy(fids)) {
+                        tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                    } catch (IOException e) {
+                        throw new InternalException("Failed to read cursor " + e);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuCapabilityTableLoader.java

@@ -0,0 +1,90 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuCapabilityTableLoader implements FirstLevelTableLoader, TableLoaderForId {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuCapabilityTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_CAPABILITY";
+    }
+
+    @Override
+    public Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter) {
+        if ((dataType == DataType.GUTDF || dataType == DataType.RUTDF) &&
+            (searchParameter == SearchParameter.FID ||
+                searchParameter == SearchParameter.PASSPORT ||
+                searchParameter == SearchParameter.OGRN)) {
+            return Set.of(getTableName());
+        }
+
+        return Set.of();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchBy(UUID taskId,
+                         DataType dataType,
+                         SearchParameter searchParameter,
+                         String searchValue,
+                         String memberCode,
+                         Map<String, Path> tableFileMap,
+                         Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.FID) {
+                Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
+
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCapability(fids)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId,
+                           DataType dataType,
+                           SearchParameter searchParameter,
+                           Set<Integer> fids,
+                           String memberCode,
+                           Map<String, Path> tableFileMap,
+                           Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
+                if (!fids.isEmpty()) {
+                    try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCapability(fids)) {
+                        tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                    } catch (IOException e) {
+                        throw new InternalException("Failed to read cursor " + e);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuDebtBurdenInfoTableLoader.java

@@ -0,0 +1,90 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuDebtBurdenInfoTableLoader implements FirstLevelTableLoader, TableLoaderForId {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuDebtBurdenInfoTableLoader(MapperHolder mapperHolder,
+                                       IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_DEBT_BURDEN_INFO";
+    }
+
+    @Override
+    public Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter) {
+        if ((dataType == DataType.GUTDF || dataType == DataType.RUTDF) &&
+            (searchParameter == SearchParameter.FID ||
+                searchParameter == SearchParameter.PASSPORT ||
+                searchParameter == SearchParameter.OGRN)) {
+            return Set.of(getTableName());
+        }
+
+        return Set.of();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchBy(UUID taskId,
+                         DataType dataType,
+                         SearchParameter searchParameter,
+                         String searchValue,
+                         String memberCode,
+                         Map<String, Path> tableFileMap,
+                         Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.FID) {
+                Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
+
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuDebtBurdenInfo(fids)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId,
+                           DataType dataType,
+                           SearchParameter searchParameter,
+                           Set<Integer> fids,
+                           String memberCode,
+                           Map<String, Path> tableFileMap,
+                           Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
+                if (!fids.isEmpty()) {
+                    try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuDebtBurdenInfo(fids)) {
+                        tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                    } catch (IOException e) {
+                        throw new InternalException("Failed to read cursor " + e);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuObligPartTakeTableLoader.java

@@ -0,0 +1,90 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuObligPartTakeTableLoader implements FirstLevelTableLoader, TableLoaderForId {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuObligPartTakeTableLoader(MapperHolder mapperHolder,
+                                      IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_OBLIGPARTTAKE";
+    }
+
+    @Override
+    public Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter) {
+        if ((dataType == DataType.GUTDF || dataType == DataType.RUTDF) &&
+            (searchParameter == SearchParameter.FID ||
+                searchParameter == SearchParameter.PASSPORT ||
+                searchParameter == SearchParameter.OGRN)) {
+            return Set.of(getTableName());
+        }
+
+        return Set.of();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchBy(UUID taskId,
+                         DataType dataType,
+                         SearchParameter searchParameter,
+                         String searchValue,
+                         String memberCode,
+                         Map<String, Path> tableFileMap,
+                         Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.FID) {
+                Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
+
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligPartTake(fids)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId,
+                           DataType dataType,
+                           SearchParameter searchParameter,
+                           Set<Integer> fids,
+                           String memberCode,
+                           Map<String, Path> tableFileMap,
+                           Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
+                if (!fids.isEmpty()) {
+                    try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligPartTake(fids)) {
+                        tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                    } catch (IOException e) {
+                        throw new InternalException("Failed to read cursor " + e);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuOtherLegalTableLoader.java

@@ -0,0 +1,90 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuOtherLegalTableLoader implements FirstLevelTableLoader, TableLoaderForId {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuOtherLegalTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_OTHERLEGAL";
+    }
+
+    @Override
+    public Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter) {
+        if ((dataType == DataType.GUTDF || dataType == DataType.RUTDF) &&
+            (searchParameter == SearchParameter.FID ||
+                searchParameter == SearchParameter.PASSPORT ||
+                searchParameter == SearchParameter.OGRN)) {
+            return Set.of(getTableName());
+        }
+
+        return Set.of();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchBy(UUID taskId,
+                         DataType dataType,
+                         SearchParameter searchParameter,
+                         String searchValue,
+                         String memberCode,
+                         Map<String, Path> tableFileMap,
+                         Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.FID) {
+                Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
+
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuOtherLegal(fids)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId,
+                           DataType dataType,
+                           SearchParameter searchParameter,
+                           Set<Integer> fids,
+                           String memberCode,
+                           Map<String, Path> tableFileMap,
+                           Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
+                if (!fids.isEmpty()) {
+                    try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuOtherLegal(fids)) {
+                        tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                    } catch (IOException e) {
+                        throw new InternalException("Failed to read cursor " + e);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuSettledTableLoader.java

@@ -0,0 +1,90 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuSettledTableLoader implements FirstLevelTableLoader, TableLoaderForId {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuSettledTableLoader(MapperHolder mapperHolder,
+                                IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_SETTLED";
+    }
+
+    @Override
+    public Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter) {
+        if ((dataType == DataType.GUTDF || dataType == DataType.RUTDF) &&
+            (searchParameter == SearchParameter.FID ||
+                searchParameter == SearchParameter.PASSPORT ||
+                searchParameter == SearchParameter.OGRN)) {
+            return Set.of(getTableName());
+        }
+
+        return Set.of();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchBy(UUID taskId,
+                         DataType dataType,
+                         SearchParameter searchParameter,
+                         String searchValue,
+                         String memberCode,
+                         Map<String, Path> tableFileMap,
+                         Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.FID) {
+                Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
+
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuSettled(fids)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId,
+                           DataType dataType,
+                           SearchParameter searchParameter,
+                           Set<Integer> fids,
+                           String memberCode,
+                           Map<String, Path> tableFileMap,
+                           Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
+                if (!fids.isEmpty()) {
+                    try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuSettled(fids)) {
+                        tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                    } catch (IOException e) {
+                        throw new InternalException("Failed to read cursor " + e);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/RuUidTableLoader.java

@@ -0,0 +1,130 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.loader.subtable.RuUidSubTableLoader;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchCommon;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuUidTableLoader implements FirstLevelTableLoader, TableLoaderForId {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+    private final List<RuUidSubTableLoader> ruUidSubTableLoaders;
+
+    public RuUidTableLoader(MapperHolder mapperHolder,
+                            IndicSearchUtils indicSearchUtils,
+                            List<RuUidSubTableLoader> ruUidSubTableLoaders) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+        this.ruUidSubTableLoaders = ruUidSubTableLoaders;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_UID";
+    }
+
+    @Override
+    public Set<String> getTableNamesIfSuitable(DataType dataType, SearchParameter searchParameter) {
+        if ((dataType == DataType.GUTDF || dataType == DataType.RUTDF) &&
+            (searchParameter == SearchParameter.UUID ||
+                searchParameter == SearchParameter.ACCT_NUM ||
+                searchParameter == SearchParameter.FID ||
+                searchParameter == SearchParameter.PASSPORT ||
+                searchParameter == SearchParameter.OGRN)) {
+            Set<String> result = new HashSet<>();
+
+            result.add(getTableName());
+            result.addAll(ruUidSubTableLoaders.stream().map(TableLoader::getTableName).toList());
+
+            return result;
+        }
+
+        return Set.of();
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchBy(UUID taskId,
+                         DataType dataType,
+                         SearchParameter searchParameter,
+                         String searchValue,
+                         String memberCode,
+                         Map<String, Path> tableFileMap,
+                         Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.UUID) {
+                if (IndicSearchCommon.isCastableField(getTableName(), "UUID")) {
+                    int maxSearchValueSize = tableMetaDataMap.get(getTableName()).getFieldMetaData().get("UUID").getColumnSize();
+                    searchValue = searchValue.length() > maxSearchValueSize ? searchValue.substring(0, maxSearchValueSize) : searchValue;
+                }
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByUuidAndMemberCodeFromRuUid(searchValue, memberCode)) {
+                    Set<Integer> foundFids = new HashSet<>();
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, foundFids, tableMetaDataMap));
+                    ruUidSubTableLoaders.parallelStream().forEach(tl -> tl.searchByRuUidFid(taskId, foundFids, tableFileMap, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            } else if (searchParameter == SearchParameter.ACCT_NUM) {
+                if (IndicSearchCommon.isCastableField(getTableName(), "ACCT_NUM")) {
+                    int maxSearchValueSize = tableMetaDataMap.get(getTableName()).getFieldMetaData().get("ACCT_NUM").getColumnSize();
+                    searchValue = searchValue.length() > maxSearchValueSize ? searchValue.substring(0, maxSearchValueSize) : searchValue;
+                }
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByAcctNumAndMemberCodeFromRuUid(searchValue, memberCode)) {
+                    Set<Integer> foundFids = new HashSet<>();
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, foundFids, tableMetaDataMap));
+                    ruUidSubTableLoaders.parallelStream().forEach(tl -> tl.searchByRuUidFid(taskId, foundFids, tableFileMap, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            } else if (searchParameter == SearchParameter.FID) {
+                Set<Integer> fids = Set.of(Integer.parseInt(searchValue));
+
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuUid(fids)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                    ruUidSubTableLoaders.parallelStream().forEach(tl -> tl.searchByRuUidFid(taskId, fids, tableFileMap, tableMetaDataMap));
+                } catch (IOException e) {
+                    throw new InternalException("Failed to read cursor " + e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId,
+                           DataType dataType,
+                           SearchParameter searchParameter,
+                           Set<Integer> fids,
+                           String memberCode,
+                           Map<String, Path> tableFileMap,
+                           Map<String, TableMetaData> tableMetaDataMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.PASSPORT || searchParameter == SearchParameter.OGRN) {
+                if (!fids.isEmpty()) {
+                    try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuUid(fids)) {
+                        tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+                        ruUidSubTableLoaders.parallelStream().forEach(tl -> tl.searchByRuUidFid(taskId, fids, tableFileMap, tableMetaDataMap));
+                    } catch (IOException e) {
+                        throw new InternalException("Failed to read cursor " + e);
+                    }
+                }
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/TableLoader.java

@@ -0,0 +1,5 @@
+package ru.nbch.indicsearchservice.loader;
+
+public interface TableLoader {
+    String getTableName();
+}

src/main/java/ru/nbch/indicsearchservice/loader/TableLoaderForId.java

@@ -0,0 +1,19 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+
+public interface TableLoaderForId extends FirstLevelTableLoader {
+    void searchById(UUID taskId,
+                    DataType dataType,
+                    SearchParameter searchParameter,
+                    Set<Integer> fids,
+                    String memberCode,
+                    Map<String, Path> tableFileMap,
+                    Map<String, TableMetaData> tableMetaDataMap);
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/AccountAmendTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class AccountAmendTableLoader implements AccountSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public AccountAmendTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "ACCOUNT_AMEND";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByAccountFid(UUID taskId,
+                                   Set<Integer> fids,
+                                   Map<String, Path> tableFileMap,
+                                   Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromAccountAmend(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/AccountSubTableLoader.java

@@ -0,0 +1,14 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+
+public interface AccountSubTableLoader extends SubTableLoader {
+    void searchByAccountFid(UUID taskId,
+                            Set<Integer> fids,
+                            Map<String, Path> tableFileMap,
+                            Map<String, TableMetaData> tableMetaDataMap);
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/BankGuaranteeTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class BankGuaranteeTableLoader implements AccountSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public BankGuaranteeTableLoader(MapperHolder mapperHolder,
+                                    IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "BANK_GUARANTEE";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByAccountFid(UUID taskId,
+                                   Set<Integer> fids,
+                                   Map<String, Path> tableFileMap,
+                                   Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromBankGuarantee(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/CollateralTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class CollateralTableLoader implements AccountSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public CollateralTableLoader(MapperHolder mapperHolder,
+                                 IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "COLLATERAL";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByAccountFid(UUID taskId,
+                                   Set<Integer> fids,
+                                   Map<String, Path> tableFileMap,
+                                   Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromCollateral(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/GuarantorTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class GuarantorTableLoader implements AccountSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public GuarantorTableLoader(MapperHolder mapperHolder,
+                                IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "GUARANTOR";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByAccountFid(UUID taskId,
+                                   Set<Integer> fids,
+                                   Map<String, Path> tableFileMap,
+                                   Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromGuarantor(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/PaymentTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class PaymentTableLoader implements AccountSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public PaymentTableLoader(MapperHolder mapperHolder,
+                              IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "PAYMENT";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByAccountFid(UUID taskId,
+                                   Set<Integer> fids,
+                                   Map<String, Path> tableFileMap,
+                                   Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromPayment(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuAccountAmtTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuAccountAmtTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuAccountAmtTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_ACCOUNT_AMT";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAccountAmt(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuAcquirerIndividTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuAcquirerIndividTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuAcquirerIndividTableLoader(MapperHolder mapperHolder,
+                                        IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_ACQUIRERINDIVID";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAcquirerIndivid(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuAcquirerLegalTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuAcquirerLegalTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuAcquirerLegalTableLoader(MapperHolder mapperHolder,
+                                      IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_ACQUIRERLEGAL";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAcquirerLegal(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuAllArrearsTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuAllArrearsTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuAllArrearsTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_ALL_ARREARS";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAllArrears(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuAmendmentTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuAmendmentTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuAmendmentTableLoader(MapperHolder mapperHolder,
+                                  IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_AMENDMENT";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAmendment(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuAmountInfoTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuAmountInfoTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuAmountInfoTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_AMOUNT_INFO";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAmountInfo(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuArrearTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuArrearTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuArrearTableLoader(MapperHolder mapperHolder,
+                               IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_ARREAR";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuArrear(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuBankruptcyBlocksTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuBankruptcyBlocksTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuBankruptcyBlocksTableLoader(MapperHolder mapperHolder,
+                                         IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_BANKRUPTCY_BLOCKS";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuBankruptcyBlocks(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuCoborrowerTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuCoborrowerTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuCoborrowerTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_COBORROWER";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCoborrower(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuCollatInsuredTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuCollatInsuredTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuCollatInsuredTableLoader(MapperHolder mapperHolder,
+                                      IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_COLLATINSURED";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCollatInsured(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuCollatRepayTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuCollatRepayTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuCollatRepayTableLoader(MapperHolder mapperHolder,
+                                    IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_COLLATREPAY";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCollatRepay(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuCollateralBlocksTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuCollateralBlocksTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuCollateralBlocksTableLoader(MapperHolder mapperHolder,
+                                         IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_COLLATERAL_BLOCKS";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCollateralBlocks(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuCollateralTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuCollateralTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuCollateralTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_COLLATERAL";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCollateral(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuContractTermsChangesTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuContractTermsChangesTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuContractTermsChangesTableLoader(MapperHolder mapperHolder,
+                                             IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_CONTRACT_TERMS_CHANGES";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuContractTermsChanges(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuDueArrearTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuDueArrearTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuDueArrearTableLoader(MapperHolder mapperHolder,
+                                  IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_DUEARREAR";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuDueArrear(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuFundDateTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuFundDateTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuFundDateTableLoader(MapperHolder mapperHolder,
+                                 IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_FUNDDATE";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuFundDate(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuGuaranteeRepayTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuGuaranteeRepayTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuGuaranteeRepayTableLoader(MapperHolder mapperHolder,
+                                       IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_GUARANTEEREPAY";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuGuaranteeRepay(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuGuarantorTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuGuarantorTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuGuarantorTableLoader(MapperHolder mapperHolder,
+                                  IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_GUARANTOR";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuGuarantor(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuIndepGuarantorTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuIndepGuarantorTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuIndepGuarantorTableLoader(MapperHolder mapperHolder,
+                                       IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_INDEPGUARANTOR";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuIndepGuarantor(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuLegalRecordTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuLegalRecordTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuLegalRecordTableLoader(MapperHolder mapperHolder,
+                                    IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_LEGALRECORD";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuLegalRecord(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuMonthAverPaymtTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuMonthAverPaymtTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuMonthAverPaymtTableLoader(MapperHolder mapperHolder,
+                                       IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_MONTHAVERPAYMT";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuMonthAverPaymt(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuObligAccountTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuObligAccountTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuObligAccountTableLoader(MapperHolder mapperHolder,
+                                     IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_OBLIGACCOUNT";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligAccount(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuObligTerminationTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuObligTerminationTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuObligTerminationTableLoader(MapperHolder mapperHolder,
+                                         IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_OBLIGTERMINATION";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligTermination(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuObligsRcBankruptTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuObligsRcBankruptTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuObligsRcBankruptTableLoader(MapperHolder mapperHolder,
+                                         IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_OBLIGSRCBANKRUPT";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligsRcBankrupt(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuObligsRcLiquidTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuObligsRcLiquidTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuObligsRcLiquidTableLoader(MapperHolder mapperHolder,
+                                       IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_OBLIGSRCLIQUID";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligsRcLiquid(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuOverallvalTableLoader.java

@@ -0,0 +1,48 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuOverallvalTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuOverallvalTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_OVERALLVAL";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuOverallval(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuPastDueArrearTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuPastDueArrearTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuPastDueArrearTableLoader(MapperHolder mapperHolder,
+                                      IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_PASTDUEARREAR";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuPastDueArrear(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuPaymtConditionTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuPaymtConditionTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuPaymtConditionTableLoader(MapperHolder mapperHolder,
+                                       IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_PAYMT_CONDITION";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuPaymtCondition(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuPaymtTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuPaymtTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuPaymtTableLoader(MapperHolder mapperHolder,
+                              IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_PAYMT";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuPaymt(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuServiceCoTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuServiceCoTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuServiceCoTableLoader(MapperHolder mapperHolder,
+                                  IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_SERVICECO";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuServiceCo(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuSourceNonMonetObligTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuSourceNonMonetObligTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuSourceNonMonetObligTableLoader(MapperHolder mapperHolder,
+                                            IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_SOURCENONMONETOBLIG";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuSourceNonMonetOblig(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuSubjectNonMonetObligTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuSubjectNonMonetObligTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuSubjectNonMonetObligTableLoader(MapperHolder mapperHolder,
+                                             IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_SUBJECTNONMONETOBLIG";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuSubjectNonMonetOblig(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuSubmitHoldTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuSubmitHoldTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuSubmitHoldTableLoader(MapperHolder mapperHolder,
+                                   IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_SUBMITHOLD";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuSubmitHold(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuTradeTableLoader.java

@@ -0,0 +1,47 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.IndicSearchUtils;
+import ru.nbch.indicsearchservice.util.MapperHolder;
+
+@Component
+public class RuTradeTableLoader implements RuUidSubTableLoader {
+    private final MapperHolder mapperHolder;
+    private final IndicSearchUtils indicSearchUtils;
+
+    public RuTradeTableLoader(MapperHolder mapperHolder,
+                              IndicSearchUtils indicSearchUtils) {
+        this.mapperHolder = mapperHolder;
+        this.indicSearchUtils = indicSearchUtils;
+    }
+
+    @Override
+    public String getTableName() {
+        return "RU_TRADE";
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchByRuUidFid(UUID taskId,
+                                 Set<Integer> fids,
+                                 Map<String, Path> tableFileMap,
+                                 Map<String, TableMetaData> tableMetaDataMap) {
+        if (!fids.isEmpty()) {
+            try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuTrade(fids)) {
+                tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, tableMetaDataMap));
+            } catch (IOException e) {
+                throw new InternalException("Failed to read cursor " + e);
+            }
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/RuUidSubTableLoader.java

@@ -0,0 +1,14 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+
+public interface RuUidSubTableLoader extends SubTableLoader {
+    void searchByRuUidFid(UUID taskId,
+                          Set<Integer> fids,
+                          Map<String, Path> tableFileMap,
+                          Map<String, TableMetaData> tableMetaDataMap);
+}

src/main/java/ru/nbch/indicsearchservice/loader/subtable/SubTableLoader.java

@@ -0,0 +1,6 @@
+package ru.nbch.indicsearchservice.loader.subtable;
+
+import ru.nbch.indicsearchservice.loader.TableLoader;
+
+public interface SubTableLoader extends TableLoader {
+}

src/main/java/ru/nbch/indicsearchservice/manager/IndicSearchJobManager.java

@@ -0,0 +1,61 @@
+package ru.nbch.indicsearchservice.manager;
+
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ExecutorService;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.dto.request.AddSearchJobRequestDto;
+import ru.nbch.indicsearchservice.model.SearchJob;
+import ru.nbch.indicsearchservice.model.enums.ExportType;
+import ru.nbch.indicsearchservice.model.enums.JobStatus;
+import ru.nbch.indicsearchservice.processor.IndicSearchProcessor;
+
+@Component
+public class IndicSearchJobManager {
+    private final ExecutorService searchJobExecutor;
+    private final Map<UUID, SearchJob> searchJobs;
+    private final IndicSearchProcessor indicSearchProcessor;
+
+    public IndicSearchJobManager(@Qualifier("searchJobExecutor") ExecutorService searchJobExecutor,
+                                 @Qualifier("searchJobsMap") Map<UUID, SearchJob> searchJobs,
+                                 IndicSearchProcessor indicSearchProcessor) {
+        this.searchJobExecutor = searchJobExecutor;
+        this.searchJobs = searchJobs;
+        this.indicSearchProcessor = indicSearchProcessor;
+    }
+
+    public UUID addSearchJob(AddSearchJobRequestDto request) {
+        UUID uuid = UUID.randomUUID();
+
+        SearchJob newSearchJob = new SearchJob(
+            uuid,
+            request.getDataType(),
+            request.getSearchParameter(),
+            request.getSearchValue(),
+            request.getMemberCode()
+        );
+        searchJobs.put(uuid, newSearchJob);
+        searchJobExecutor.submit(() -> indicSearchProcessor.aggregateTables(newSearchJob));
+
+        return uuid;
+    }
+
+    public JobStatus getJobStatus(UUID id) {
+        SearchJob searchJob = searchJobs.get(id);
+        if (searchJob != null) {
+            return searchJob.getJobStatus();
+        }
+        return null;
+    }
+
+    public ResponseEntity<?> export(UUID id, ExportType exportType) {
+        SearchJob searchJob = searchJobs.get(id);
+        if (searchJob == null) {
+            return ResponseEntity.notFound().build();
+        }
+
+        return indicSearchProcessor.export(searchJob, exportType);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/model/SearchJob.java

@@ -0,0 +1,134 @@
+package ru.nbch.indicsearchservice.model;
+
+import java.nio.file.Path;
+import java.time.LocalDateTime;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.JobStatus;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+
+public class SearchJob {
+    private final UUID uuid;
+    private final DataType dataType;
+    private final SearchParameter searchParameter;
+    private final String searchValue;
+    private final String memberCode;
+
+    private JobStatus jobStatus;
+    private Path aggregatedFilePath;
+    private Long rowCount;
+    private Map<String, TableMetaData> tableMetaDataMap;
+
+    private LocalDateTime createdAt;
+    private LocalDateTime finishedAt;
+
+    public SearchJob(UUID uuid, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode) {
+        this.uuid = uuid;
+        this.dataType = dataType;
+        this.searchParameter = searchParameter;
+        this.searchValue = searchValue;
+        this.memberCode = memberCode;
+
+        this.setJobStatus(JobStatus.QUEUED);
+        this.createdAt = LocalDateTime.now();
+    }
+
+    public UUID getUuid() {
+        return uuid;
+    }
+
+    public DataType getDataType() {
+        return dataType;
+    }
+
+    public SearchParameter getSearchParameter() {
+        return searchParameter;
+    }
+
+    public String getSearchValue() {
+        return searchValue;
+    }
+
+    public String getMemberCode() {
+        return memberCode;
+    }
+
+    public JobStatus getJobStatus() {
+        return jobStatus;
+    }
+
+    public void setJobStatus(JobStatus jobStatus) {
+        this.jobStatus = jobStatus;
+    }
+
+    public Path getAggregatedFilePath() {
+        return aggregatedFilePath;
+    }
+
+    public void setAggregatedFilePath(Path aggregatedFilePath) {
+        this.aggregatedFilePath = aggregatedFilePath;
+    }
+
+    public Long getRowCount() {
+        return rowCount;
+    }
+
+    public void setRowCount(Long rowCount) {
+        this.rowCount = rowCount;
+    }
+
+    public Map<String, TableMetaData> getTableMetaDataMap() {
+        return tableMetaDataMap;
+    }
+
+    public void setTableMetaDataMap(Map<String, TableMetaData> tableMetaDataMap) {
+        this.tableMetaDataMap = tableMetaDataMap;
+    }
+
+    public LocalDateTime getCreatedAt() {
+        return createdAt;
+    }
+
+    public void setCreatedAt(LocalDateTime createdAt) {
+        this.createdAt = createdAt;
+    }
+
+    public LocalDateTime getFinishedAt() {
+        return finishedAt;
+    }
+
+    public void setFinishedAt(LocalDateTime finishedAt) {
+        this.finishedAt = finishedAt;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == null || getClass() != o.getClass()) return false;
+        SearchJob searchJob = (SearchJob) o;
+        return Objects.equals(uuid, searchJob.uuid) && dataType == searchJob.dataType && searchParameter == searchJob.searchParameter && Objects.equals(searchValue, searchJob.searchValue) && Objects.equals(memberCode, searchJob.memberCode) && jobStatus == searchJob.jobStatus && Objects.equals(aggregatedFilePath, searchJob.aggregatedFilePath) && Objects.equals(rowCount, searchJob.rowCount) && Objects.equals(tableMetaDataMap, searchJob.tableMetaDataMap) && Objects.equals(createdAt, searchJob.createdAt) && Objects.equals(finishedAt, searchJob.finishedAt);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(uuid, dataType, searchParameter, searchValue, memberCode, jobStatus, aggregatedFilePath, rowCount, tableMetaDataMap, createdAt, finishedAt);
+    }
+
+    @Override
+    public String toString() {
+        return "SearchJob{" +
+            "uuid=" + uuid +
+            ", dataType=" + dataType +
+            ", searchParameter=" + searchParameter +
+            ", searchValue='" + searchValue + '\'' +
+            ", memberCode='" + memberCode + '\'' +
+            ", jobStatus=" + jobStatus +
+            ", filePath=" + aggregatedFilePath +
+            ", rowCount=" + rowCount +
+            ", tableMetaDataMap=" + tableMetaDataMap +
+            ", createdAt=" + createdAt +
+            ", finishedAt=" + finishedAt +
+            '}';
+    }
+}

src/main/java/ru/nbch/indicsearchservice/model/Settings.java

@@ -16,7 +16,7 @@ public class Settings {
     public Settings() {
     }
 
-    public Settings(Long id, Long version, String name, String value) {
+    public Settings(Long id, @Nullable Long version, @Nullable String name, @Nullable String value) {
         this.id = id;
         this.version = version;
         this.name = name;
@@ -31,27 +31,28 @@ public class Settings {
         this.id = id;
     }
 
+    @Nullable
     public Long getVersion() {
         return version;
     }
 
-    public void setVersion(Long version) {
+    public void setVersion(@Nullable Long version) {
         this.version = version;
     }
 
-    public String getName() {
+    public @Nullable String getName() {
         return name;
     }
 
-    public void setName(String name) {
+    public void setName(@Nullable String name) {
         this.name = name;
     }
 
-    public String getValue() {
+    public @Nullable String getValue() {
         return value;
     }
 
-    public void setValue(String value) {
+    public void setValue(@Nullable String value) {
         this.value = value;
     }
 

src/main/java/ru/nbch/indicsearchservice/model/TableData.java

@@ -0,0 +1,67 @@
+package ru.nbch.indicsearchservice.model;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonPropertyOrder;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+
+@JsonPropertyOrder({"tableName", "fieldData", "relatedTableData"})
+public class TableData {
+    private String tableName;
+    private List<FieldData> fieldData = new ArrayList<>();
+
+    @JsonProperty("related_data")
+    private List<TableData> relatedTableData = new ArrayList<>();
+
+    public TableData() {
+    }
+
+    public TableData(String tableName, List<FieldData> fieldData) {
+        this.tableName = tableName;
+        this.fieldData = fieldData;
+    }
+
+    public TableData(String tableName, List<FieldData> fieldData, List<TableData> relatedTableData) {
+        this.tableName = tableName;
+        this.fieldData = fieldData;
+        this.relatedTableData = relatedTableData;
+    }
+
+    public String getTableName() {
+        return tableName;
+    }
+
+    public List<FieldData> getFieldData() {
+        return fieldData;
+    }
+
+    public List<TableData> getRelatedTableData() {
+        return relatedTableData;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == null || getClass() != o.getClass()) return false;
+        TableData tableData = (TableData) o;
+        return Objects.equals(tableName, tableData.tableName) && Objects.equals(fieldData, tableData.fieldData) && Objects.equals(relatedTableData, tableData.relatedTableData);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(tableName, fieldData, relatedTableData);
+    }
+
+    @Override
+    public String toString() {
+        return "TableData{" +
+            "tableName='" + tableName + '\'' +
+            ", fieldData=" + fieldData +
+            ", relatedTableData=" + relatedTableData +
+            '}';
+    }
+
+    public record FieldData(@JsonProperty("key") String columnName,
+                            @JsonProperty("value") Object columnValue) {
+    }
+}

src/main/java/ru/nbch/indicsearchservice/model/TableMetaData.java

@@ -0,0 +1,98 @@
+package ru.nbch.indicsearchservice.model;
+
+import jakarta.annotation.Nullable;
+import java.sql.JDBCType;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class TableMetaData {
+    private final String tableName;
+    private String tableNameLocalization;
+    private final Map<String, FieldMetaData> fieldMetaData = new LinkedHashMap<>();
+
+    public TableMetaData(String tableName) {
+        this.tableName = tableName;
+    }
+
+    public String getTableName() {
+        return tableName;
+    }
+
+    public String getTableNameLocalization() {
+        return tableNameLocalization;
+    }
+
+    public void setTableNameLocalization(String tableNameLocalization) {
+        this.tableNameLocalization = tableNameLocalization;
+    }
+
+    public Map<String, FieldMetaData> getFieldMetaData() {
+        return Collections.unmodifiableMap(fieldMetaData);
+    }
+
+    public boolean addField(String fieldName) {
+        if (fieldMetaData.containsKey(fieldName)) {
+            return false;
+        }
+        fieldMetaData.put(fieldName, new FieldMetaData(fieldName));
+        return true;
+    }
+
+    public void addLocalization(String fieldName, String fieldLocalization) {
+        fieldMetaData.compute(fieldName, (key, existingRecord) ->
+            new FieldMetaData(fieldName, fieldLocalization)
+        );
+    }
+
+    public static class FieldMetaData {
+        private final String fieldName;
+        @Nullable
+        private final String fieldLocalization;
+        @Nullable
+        private JDBCType jdbcType;
+        @Nullable
+        private Integer columnSize;
+
+        public FieldMetaData(String fieldName, @Nullable String fieldLocalization) {
+            this.fieldName = fieldName;
+            this.fieldLocalization = fieldLocalization;
+            this.jdbcType = null;
+            this.columnSize = null;
+        }
+
+        public FieldMetaData(String fieldName) {
+            this.fieldName = fieldName;
+            this.fieldLocalization = null;
+            this.jdbcType = null;
+            this.columnSize = null;
+        }
+
+        public String getFieldName() {
+            return fieldName;
+        }
+
+        @Nullable
+        public String getFieldLocalization() {
+            return fieldLocalization;
+        }
+
+        @Nullable
+        public JDBCType getJdbcType() {
+            return jdbcType;
+        }
+
+        @Nullable
+        public Integer getColumnSize() {
+            return columnSize;
+        }
+
+        public void setJdbcType(@Nullable JDBCType jdbcType) {
+            this.jdbcType = jdbcType;
+        }
+
+        public void setColumnSize(@Nullable Integer columnSize) {
+            this.columnSize = columnSize;
+        }
+    }
+}

src/main/java/ru/nbch/indicsearchservice/model/enums/ExportType.java

@@ -0,0 +1,6 @@
+package ru.nbch.indicsearchservice.model.enums;
+
+public enum ExportType {
+    XLSX,
+    JSON
+}

src/main/java/ru/nbch/indicsearchservice/processor/IndicSearchProcessor.java

@@ -0,0 +1,207 @@
+package ru.nbch.indicsearchservice.processor;
+
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import org.apache.commons.lang3.mutable.MutableLong;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.core.io.InputStreamResource;
+import org.springframework.http.ContentDisposition;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StopWatch;
+import ru.nbch.indicsearchservice.aggregator.FileAggregator;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.exporter.ExcelExporter;
+import ru.nbch.indicsearchservice.exporter.JsonExporter;
+import ru.nbch.indicsearchservice.loader.FirstLevelTableLoader;
+import ru.nbch.indicsearchservice.model.SearchJob;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.ExportType;
+import ru.nbch.indicsearchservice.model.enums.JobStatus;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.TableMetaDataUtil;
+
+@Component
+public class IndicSearchProcessor {
+    private static final Logger log = LoggerFactory.getLogger(IndicSearchProcessor.class);
+
+    private final List<FirstLevelTableLoader> tableLoaders;
+    private final List<FileAggregator> fileAggregators;
+    private final ExcelExporter excelExporter;
+    private final JsonExporter jsonExporter;
+    private final TableMetaDataUtil tableMetaDataUtil;
+
+    public IndicSearchProcessor(List<FirstLevelTableLoader> tableLoaders,
+                                List<FileAggregator> fileAggregators,
+                                ExcelExporter excelExporter,
+                                JsonExporter jsonExporter,
+                                TableMetaDataUtil tableMetaDataUtil) {
+        this.tableLoaders = tableLoaders;
+        this.fileAggregators = fileAggregators;
+        this.excelExporter = excelExporter;
+        this.jsonExporter = jsonExporter;
+        this.tableMetaDataUtil = tableMetaDataUtil;
+    }
+
+    public void aggregateTables(SearchJob job) {
+        job.setJobStatus(JobStatus.IN_PROGRESS);
+
+        StopWatch sw = new StopWatch();
+
+        // Подготовительный этап. Получение мета данных из БД
+        log.info("Prep step started. Getting metadata from database");
+        sw.start();
+
+        Map<String, TableMetaData> tableMetaDataMap = tableMetaDataUtil.prepareTableMetaData(job.getDataType(), job.getSearchParameter());
+        job.setTableMetaDataMap(tableMetaDataMap);
+
+        sw.stop();
+        log.info(sw.prettyPrint());
+        sw = new StopWatch();
+
+        // Первый этап. Получение данных из БД и заполнение файлов
+        log.info("First step started. Getting data from database and filling csv files");
+        sw.start();
+
+        Map<String, Path> tableFileMap = new ConcurrentHashMap<>();
+        tableLoaders.parallelStream().forEach(tl -> tl.searchBy(
+            job.getUuid(),
+            job.getDataType(),
+            job.getSearchParameter(),
+            job.getSearchValue(),
+            job.getMemberCode().substring(0, 6),
+            tableFileMap,
+            tableMetaDataMap
+        ));
+
+        sw.stop();
+        log.info(sw.prettyPrint());
+        sw = new StopWatch();
+
+        // Второй этап. Объединение файлов в один
+        log.info("Second step started. Aggregating table files into one.");
+        sw.start();
+
+        MutableLong rowCounter = new MutableLong();
+        Path aggregatedFile = fileAggregators.stream().map(fa -> fa.aggregateFiles(
+                job.getUuid(),
+                job.getDataType(),
+                job.getSearchParameter(),
+                job.getSearchValue(),
+                job.getMemberCode().substring(0, 6),
+                tableFileMap,
+                rowCounter))
+            .filter(Objects::nonNull)
+            .findFirst()
+            .orElse(null);
+
+        job.setAggregatedFilePath(aggregatedFile);
+        job.setRowCount(rowCounter.longValue());
+        job.setFinishedAt(LocalDateTime.now());
+        job.setJobStatus(JobStatus.DONE);
+
+        sw.stop();
+        log.info(sw.prettyPrint());
+
+        for (Path tableFilePath : tableFileMap.values()) {
+            try {
+                Files.deleteIfExists(tableFilePath);
+            } catch (IOException e) {
+                throw new InternalException("Failed to delete file " + tableFilePath + " " + e);
+            }
+        }
+    }
+
+    public ResponseEntity<?> export(SearchJob job, ExportType exportType) {
+        StopWatch sw = new StopWatch();
+        sw.start();
+
+        UUID taskId = job.getUuid();
+        SearchParameter searchParameter = job.getSearchParameter();
+
+        Path aggregatedFile = job.getAggregatedFilePath();
+
+        long rowCount = job.getRowCount();
+        Map<String, TableMetaData> tableMetaDataMap = job.getTableMetaDataMap();
+
+        Path exportedFile;
+        String fileName = "err.txt";
+        if (exportType == ExportType.JSON) {
+            fileName = "output.json";
+            exportedFile = jsonExporter.writeJsonFile(aggregatedFile, taskId, searchParameter, tableMetaDataMap);
+        } else if (exportType == ExportType.XLSX) {
+            fileName = "NBKI table.xlsx";
+            tableMetaDataUtil.fillTableMetaDataWithLocalization(tableMetaDataMap);
+            exportedFile = excelExporter.writeExcelFile(aggregatedFile, taskId, rowCount, tableMetaDataMap);
+        } else {
+            exportedFile = null;
+        }
+
+//        long rowLimit = Long.parseLong(settingsService.getSettingsValueByName("LimitDB"));
+//        if (rowCount < rowLimit && !IS_EXPORT_AS_EXCEL) {
+//            jsonExporter.writeJsonFile(aggregatedFile, taskId, searchParameter, tableMetaDataMap);
+//        } else {
+//            tableMetaDataUtil.fillTableMetaDataWithLocalization(tableMetaDataMap);
+//            excelExporter.writeExcelFile(aggregatedFile, taskId, rowCount, tableMetaDataMap);
+//        }
+
+        sw.stop();
+        log.info(sw.prettyPrint());
+
+        if (exportedFile == null) {
+            return ResponseEntity.internalServerError().build();
+        }
+
+        long contentLength;
+        try {
+            contentLength = Files.size(exportedFile);
+        } catch (IOException e) {
+            log.error("Failed to get temp excel file size!", e);
+            try {
+                Files.deleteIfExists(exportedFile);
+            } catch (IOException ignored) {
+            }
+            throw new InternalException("Failed to get exported file size! " + e);
+        }
+
+        InputStreamResource exportedFileResource;
+        try {
+            exportedFileResource = new InputStreamResource(new FileInputStream(exportedFile.toFile()) {
+                @Override
+                public void close() throws IOException {
+                    super.close();
+                    Files.deleteIfExists(exportedFile);
+                }
+            });
+        } catch (IOException e) {
+            log.error("Failed to create exported file resource!", e);
+            try {
+                Files.deleteIfExists(exportedFile);
+            } catch (IOException ignored) {
+            }
+            throw new InternalException("Failed to create exported file resource! " + e);
+        }
+
+        return ResponseEntity.ok()
+            .contentType(MediaType.APPLICATION_OCTET_STREAM)
+            .contentLength(contentLength)
+            .header(HttpHeaders.CONTENT_DISPOSITION,
+                ContentDisposition.attachment()
+                    .filename(fileName, StandardCharsets.UTF_8)
+                    .build()
+                    .toString())
+            .body(exportedFileResource);
+    }
+}

src/main/java/ru/nbch/indicsearchservice/repository/bank/LocalizationObjectMapper.java

@@ -7,11 +7,7 @@ import ru.nbch.indicsearchservice.model.LocalizationObject;
 
 @Mapper
 public interface LocalizationObjectMapper {
-    List<LocalizationObject> findByCode(String code);
-
     List<LocalizationObject> findAllByCodes(@Param("codes") List<String> codes);
 
-    void insert(LocalizationObject localization);
-
     void insertBatch(@Param("list") List<LocalizationObject> list);
 }

src/main/java/ru/nbch/indicsearchservice/repository/bank/SettingsMapper.java

@@ -1,6 +1,5 @@
 package ru.nbch.indicsearchservice.repository.bank;
 
-import java.util.Collection;
 import java.util.List;
 import java.util.Optional;
 import org.apache.ibatis.annotations.Mapper;
@@ -13,5 +12,5 @@ public interface SettingsMapper {
 
     List<Settings> findAllByNames(@Param("names") List<String> names);
 
-    Collection<Settings> findAll();
+    void insertBatch(@Param("list") List<Settings> list);
 }

src/main/java/ru/nbch/indicsearchservice/repository/indic/IndicMapper.java

@@ -2,6 +2,7 @@ package ru.nbch.indicsearchservice.repository.indic;
 
 import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Set;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.cursor.Cursor;
 import ru.nbch.indicsearchservice.repository.MyBatisRepository;
@@ -10,169 +11,78 @@ import ru.nbch.indicsearchservice.repository.MyBatisRepository;
 public interface IndicMapper extends MyBatisRepository {
     List<LinkedHashMap<String, String>> getTableColumnsByTableNames(List<String> tables);
 
-    List<LinkedHashMap<String, Object>> findAllByAcctNumAndMemberCodeFromRuUid(String columns, String acctNum, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByAcctNumAndMemberCodeFromRuUidCursor(String columns, String acctNum, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByApplicationNumberAndMemberCodeFromRuApplication(String columns, String applicationNumber, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByApplicationNumberAndMemberCodeFromRuApplicationCursor(String columns, String applicationNumber, String memberCode);
-    Long countAllByApplicationNumberAndMemberCodeFromRuApplication(String applicationNumber, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByUuidFromRuUid(String columns, String uuid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByUuidFromRuUidCursor(String columns, String uuid, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByOgrnFromId(String idNorm);
-    Cursor<LinkedHashMap<String, Object>> findAllByOgrnFromIdCursor(String idNorm);
-    List<String> findAllDistinctFidByOgrnFromId(String idNorm);
-    List<LinkedHashMap<String, Object>> findAllByOgrnTutdfFromId(String idNorm);
-    Cursor<LinkedHashMap<String, Object>> findAllByOgrnTutdfFromIdCursor(String idNorm);
-    List<String> findAllDistinctFidByOgrnTutdfFromId(String idNorm);
-    List<LinkedHashMap<String, Object>> findAllByPassportFromId(String idNorm);
-    Cursor<LinkedHashMap<String, Object>> findAllByPassportFromIdCursor(String idNorm);
-    List<String> findAllDistinctFidByPassportFromId(String idNorm);
-    List<LinkedHashMap<String, Object>> findAllByPassportTutdfFromId(String idNorm);
-    Cursor<LinkedHashMap<String, Object>> findAllByPassportTutdfFromIdCursor(String idNorm);
-    List<String> findAllDistinctFidByPassportTutdfFromId(String idNorm);
-    List<LinkedHashMap<String, Object>> findAllByOldAppNumFromRuApplication(String columns, String oldAppNum, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByOldAppNumFromRuApplicationCursor(String columns, String oldAppNum, String memberCode);
-    Long countAllByOldAppNumFromRuApplication(String oldAppNum, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByAcctNumFromAccount(String columns, String acctNum, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByAcctNumFromAccountCursor(String columns, String acctNum, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllBySerialNumFromAccount(String columns, String serialNum, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllBySerialNumFromAccountCursor(String columns, String serialNum, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByUuidFromAccount(String columns, String uuid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByUuidFromAccountCursor(String columns, String uuid, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllBySerialNumAndMemberCodeFromInformation(String columns, String serialNum, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllBySerialNumAndMemberCodeFromInformationCursor(String columns, String serialNum, String memberCode);
-    Long countAllBySerialNumAndMemberCodeFromInformation(String serialNum, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByAppNumAndMemberCodeFromInformation(String columns, String appNum, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByAppNumAndMemberCodeFromInformationCursor(String columns, String appNum, String memberCode);
-    Long countAllByAppNumAndMemberCodeFromInformation(String appNum, String memberCode);
+    // GUTDF/RUTDF tables
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuUid(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuApplication(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuObligPartTake(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuBankruptcy(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuSettled(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuOtherLegal(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCapability(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuDebtBurdenInfo(Set<Integer> fids);
 
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuTrade(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuTradeCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAccountAmt(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAccountAmtCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCoborrower(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCoborrowerCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPaymtCondition(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPaymtConditionCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuOverallval(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuOverallvalCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAmendment(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAmendmentCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuFunddate(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuFunddateCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuArrear(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuArrearCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuDuearrear(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuDuearrearCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPastduearrear(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPastduearrearCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPaymt(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPaymtCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuMonthaverpaymt(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuMonthaverpaymtCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSourcenonmonetoblig(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSourcenonmonetobligCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSubjectnonmonetoblig(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSubjectnonmonetobligCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCollateral(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCollateralCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuGuarantor(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuGuarantorCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuIndepguarantor(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuIndepguarantorCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCollatinsured(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCollatinsuredCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCollatrepay(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCollatrepayCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuGuaranteerepay(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuGuaranteerepayCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligtermination(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligterminationCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSubmithold(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSubmitholdCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAcquirerlegal(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAcquirerlegalCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAcquirerindivid(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAcquirerindividCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuServiceco(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuServicecoCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligaccount(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligaccountCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuLegalrecord(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuLegalrecordCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligsrcbankrupt(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligsrcbankruptCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligsrcliquid(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuObligsrcliquidCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAmountInfo(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAmountInfoCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuContractTermsChanges(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuContractTermsChangesCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAllArrears(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAllArrearsCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromAccountAmend(String columns, String accSerialNum, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromAccountAmendCursor(String columns, String accSerialNum, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromPayment(String columns, String accSerialNum, String memberCode, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromPaymentCursor(String columns, String accSerialNum, String memberCode, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromCollateral(String columns, String accSerialNum, String memberCode, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromCollateralCursor(String columns, String accSerialNum, String memberCode, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromGuarantor(String columns, String accSerialNum, String memberCode, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromGuarantorCursor(String columns, String accSerialNum, String memberCode, String fid);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromBankGuarantee(String columns, String accSerialNum, String memberCode, String fid);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromBankGuaranteeCursor(String columns, String accSerialNum, String memberCode, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByAcctNumAndMemberCodeFromRuUid(String acctNum, String memberCode);
+    Cursor<LinkedHashMap<String, Object>> findAllByUuidAndMemberCodeFromRuUid(String uuid, String memberCode);
+    Cursor<LinkedHashMap<String, Object>> findAllByApplicationNumberAndMemberCodeFromRuApplication(String applicationNumber, String memberCode);
+    Cursor<LinkedHashMap<String, Object>> findAllByOldAppNumAndMemberCodeFromRuApplication(String oldAppNum, String memberCode);
 
-    List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuUid(String columns, String fid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuUidCursor(String columns, String fid, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuUidWithoutRealMemberCode(String columns, String fid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuUidWithoutRealMemberCodeCursor(String columns, String fid, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuApplication(String columns, String fid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuApplicationCursor(String columns, String fid, String memberCode);
-    Long countAllByFidAndMemberCodeFromRuApplication(String fid, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuObligparttake(String columns, String fid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuObligparttakeCursor(String columns, String fid, String memberCode);
-    Long countAllByFidAndMemberCodeFromRuObligparttake(String fid, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuBankruptcy(String columns, String fid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuBankruptcyCursor(String columns, String fid, String memberCode);
-    Long countAllByFidAndMemberCodeFromRuBankruptcyWithBlocks(String fid, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuSettled(String columns, String fid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuSettledCursor(String columns, String fid, String memberCode);
-    Long countAllByFidAndMemberCodeFromRuSettled(String fid, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuOtherlegal(String columns, String fid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuOtherlegalCursor(String columns, String fid, String memberCode);
-    Long countAllByFidAndMemberCodeFromRuOtherlegal(String fid, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuCapability(String columns, String fid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuCapabilityCursor(String columns, String fid, String memberCode);
-    Long countAllByFidAndMemberCodeFromRuCapability(String fid, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuDebtBurdenInfo(String columns, String fid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromRuDebtBurdenInfoCursor(String columns, String fid, String memberCode);
-    Long countAllByFidAndMemberCodeFromRuDebtBurdenInfo(String fid, String memberCode);
+    Cursor<LinkedHashMap<String, Object>> findFidsByOgrnFromId(String idNorm);
+    Cursor<LinkedHashMap<String, Object>> findFidsByPassportFromId(String idNorm);
 
-    List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromAccount(String columns, String fid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromAccountCursor(String columns, String fid, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromInformation(String columns, String fid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromInformationCursor(String columns, String fid, String memberCode);
-    Long countAllByFidAndMemberCodeFromInformation(String fid, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromBankruptcy(String columns, String fid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromBankruptcyCursor(String columns, String fid, String memberCode);
-    Long countAllByFidAndMemberCodeFromBankruptcy(String fid, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromConsumerBankruptcy(String columns, String fid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromConsumerBankruptcyCursor(String columns, String fid, String memberCode);
-    Long countAllByFidAndMemberCodeFromConsumerBankruptcy(String fid, String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromLegal(String columns, String fid, String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndMemberCodeFromLegalCursor(String columns, String fid, String memberCode);
-    Long countAllByFidAndMemberCodeFromLegal(String fid, String memberCode);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuTrade(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAccountAmt(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAcquirerIndivid(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAcquirerLegal(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAllArrears(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAmendment(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAmountInfo(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuArrear(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuBankruptcyBlocks(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCoborrower(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCollateral(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCollateralBlocks(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCollatInsured(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCollatRepay(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuContractTermsChanges(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuDueArrear(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuFundDate(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuGuaranteeRepay(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuGuarantor(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuIndepGuarantor(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuLegalRecord(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuMonthAverPaymt(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuObligAccount(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuObligsRcBankrupt(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuObligsRcLiquid(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuObligTermination(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuOverallval(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuPastDueArrear(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuPaymtCondition(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuPaymt(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuServiceCo(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuSourceNonMonetOblig(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuSubjectNonMonetOblig(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuSubmitHold(Set<Integer> fids);
 
-    List<LinkedHashMap<String, Object>> findAllByFidAndParentSerialNumFromRuCollateralBlocks(String columns, String fid, String parentSerialNum);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndParentSerialNumFromRuCollateralBlocksCursor(String columns, String fid, String parentSerialNum);
-    List<LinkedHashMap<String, Object>> findAllByFidAndParentSerialNumFromRuBankruptcyBlocks(String columns, String fid, String parentSerialNum);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidAndParentSerialNumFromRuBankruptcyBlocksCursor(String columns, String fid, String parentSerialNum);
+    // TUTDF tables
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromAccount(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromInformation(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromBankruptcy(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromConsumerBankruptcy(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromLegal(Set<Integer> fids);
 
-    List<LinkedHashMap<String, Object>> countAllRuUidChildTablesByAcctNum(String acctNum, String memberCode);
-    List<LinkedHashMap<String, Object>> countAllRuUidChildTablesByFid(String fid, String memberCode);
-    List<LinkedHashMap<String, Object>> countAllRuUidChildTablesByFidWithoutRealMemberCode(String fid, String memberCode);
-    List<LinkedHashMap<String, Object>> countAllRuUidChildTablesByUuid(String uuid, String memberCode);
+    Cursor<LinkedHashMap<String, Object>> findAllByAcctNumAndMemberCodeFromAccount(String acctNum, String memberCode);
+    Cursor<LinkedHashMap<String, Object>> findAllBySerialNumAndMemberCodeFromAccount(String serialNum, String memberCode);
+    Cursor<LinkedHashMap<String, Object>> findAllByUuidAndMemberCodeFromAccount(String uuid, String memberCode);
+    Cursor<LinkedHashMap<String, Object>> findAllBySerialNumAndMemberCodeFromInformation(String serialNum, String memberCode);
+    Cursor<LinkedHashMap<String, Object>> findAllByAppNumAndMemberCodeFromInformation(String appNum, String memberCode);
 
-    List<LinkedHashMap<String, Object>> countAllAccountChildTablesByAcctNum(String acctNum, String memberCode);
-    List<LinkedHashMap<String, Object>> countAllAccountChildTablesByFid(String fid, String memberCode);
-    List<LinkedHashMap<String, Object>> countAllAccountChildTablesBySerialNum(String serialNum, String memberCode);
-    List<LinkedHashMap<String, Object>> countAllAccountChildTablesByUuid(String uuid, String memberCode);
+    Cursor<LinkedHashMap<String, Object>> findFidsByOgrnFromIdForTutdf(String idNorm);
+    Cursor<LinkedHashMap<String, Object>> findFidsByPassportFromIdForTutdf(String idNorm);
+
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromAccountAmend(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromPayment(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromCollateral(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromGuarantor(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromBankGuarantee(Set<Integer> fids);
 }

src/main/java/ru/nbch/indicsearchservice/service/IndicSearchService.java

@@ -1,22 +1,36 @@
 package ru.nbch.indicsearchservice.service;
 
+import java.util.UUID;
 import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 import ru.nbch.indicsearchservice.dto.request.AddSearchJobRequestDto;
 import ru.nbch.indicsearchservice.dto.response.AddSearchJobResponseDto;
 import ru.nbch.indicsearchservice.dto.response.JobStatusResponseDto;
+import ru.nbch.indicsearchservice.manager.IndicSearchJobManager;
+import ru.nbch.indicsearchservice.model.enums.ExportType;
+import ru.nbch.indicsearchservice.model.enums.JobStatus;
 
 @Service
 public class IndicSearchService {
+    private final IndicSearchJobManager indicSearchJobManager;
+
+    public IndicSearchService(IndicSearchJobManager indicSearchJobManager) {
+        this.indicSearchJobManager = indicSearchJobManager;
+    }
+
     public AddSearchJobResponseDto addSearchJob(AddSearchJobRequestDto request) {
-        return null;
+        UUID jobId = indicSearchJobManager.addSearchJob(request);
+
+        return new AddSearchJobResponseDto(jobId);
     }
 
-    public JobStatusResponseDto getJobStatus(Long id) {
-        return null;
+    public JobStatusResponseDto getJobStatus(UUID id) {
+        JobStatus jobStatus = indicSearchJobManager.getJobStatus(id);
+
+        return new JobStatusResponseDto(jobStatus);
     }
 
-    public ResponseEntity<?> export(Long id, String exportType) {
-        return null;
+    public ResponseEntity<?> export(UUID id, ExportType exportType) {
+        return indicSearchJobManager.export(id, exportType);
     }
 }

src/main/java/ru/nbch/indicsearchservice/service/SettingsService.java

@@ -4,20 +4,26 @@ import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Paths;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.stream.Collectors;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.stereotype.Service;
 import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.cron.CronJobName;
+import ru.nbch.indicsearchservice.event.CronChangedEvent;
 import ru.nbch.indicsearchservice.event.DataSourceChangedEvent;
+import ru.nbch.indicsearchservice.exception.InternalException;
 import ru.nbch.indicsearchservice.model.Settings;
 import ru.nbch.indicsearchservice.repository.bank.SettingsMapper;
 import ru.nbch.indicsearchservice.util.DataSourceUpdater;
 
 @Service
 public class SettingsService {
+    private static final String STORAGE_SETTINGS = "indic-search-service-storage"; // todo: change key
+    private static final String JOB_CLEANER_SETTINGS = "jobCleaner";
+
     private final SettingsMapper settingsMapper;
     private final ApplicationSettings localSettings;
     private final ApplicationEventPublisher publisher;
@@ -30,23 +36,30 @@ public class SettingsService {
         this.publisher = publisher;
     }
 
-    public String getSettingsValueByName(String name) {
-        return settingsMapper.findByName(name)
-            .orElseThrow(() -> new RuntimeException("Setting with key: " + name + " was not found in database!"))
-            .getValue();
-    }
-
     public Map<String, Optional<String>> getSettingsValuesByNames(List<String> names) {
         if (names == null || names.isEmpty()) {
             return Map.of();
         }
 
-        List<Settings> foundValues = settingsMapper.findAllByNames(names);
-        if (foundValues == null || foundValues.isEmpty()) {
-            return Map.of();
+        Map<String, Optional<String>> resultMap = new HashMap<>();
+        for (String name : names) {
+            if (name != null) {
+                resultMap.put(name, Optional.empty());
+            }
         }
 
-        return foundValues.stream().collect(Collectors.toMap(Settings::getName, s -> Optional.ofNullable(s.getValue())));
+        List<Settings> foundValues = settingsMapper.findAllByNames(names);
+        if (foundValues == null || foundValues.isEmpty()) {
+            return resultMap;
+        }
+
+        for (Settings setting : foundValues) {
+            if (setting != null && setting.getName() != null) {
+                resultMap.put(setting.getName(), Optional.ofNullable(setting.getValue()));
+            }
+        }
+
+        return resultMap;
     }
 
     public Optional<String> getOptionalSettingsValueByName(String name) {
@@ -54,17 +67,29 @@ public class SettingsService {
     }
 
     public void updateLocalSettings() {
-        Optional<String> newStorageDirectory = getOptionalSettingsValueByName("indic-search-service-storage"); // todo: change key
+        Map<String, Optional<String>> newSettings = getSettingsValuesByNames(List.of(
+            STORAGE_SETTINGS,
+            JOB_CLEANER_SETTINGS + ".enabled",
+            JOB_CLEANER_SETTINGS + ".cron"
+        ));
+
+        if (newSettings.get(STORAGE_SETTINGS).isPresent()) {
+            String newStorageDirectory = newSettings.get(STORAGE_SETTINGS).get();
+            try {
+                Files.createDirectories(Paths.get(newStorageDirectory));
+            } catch (IOException e) {
+                throw new InternalException("Failed to create directory " + newStorageDirectory + " " + e);
+            }
+            localSettings.setStorageDirectory(new File(newStorageDirectory));
+        }
+
+        if (newSettings.get(JOB_CLEANER_SETTINGS + ".enabled").isPresent()) {
+            localSettings.getJobCleaner().setEnabled(Boolean.parseBoolean(newSettings.get(JOB_CLEANER_SETTINGS + ".enabled").get()));
+        }
+        if (newSettings.get(JOB_CLEANER_SETTINGS + ".cron").isPresent()) {
+            publisher.publishEvent(new CronChangedEvent(CronJobName.JOB_CLEANER, newSettings.get(JOB_CLEANER_SETTINGS + ".cron").get()));
+        }
 
         publisher.publishEvent(new DataSourceChangedEvent(DataSourceUpdater.DataSourceType.INDIC));
-
-        if (newStorageDirectory.isPresent()) {
-            try {
-                Files.createDirectories(Paths.get(newStorageDirectory.get()));
-            } catch (IOException e) {
-                throw new RuntimeException(e);
-            }
-            localSettings.setStorageDirectory(new File(newStorageDirectory.get()));
-        }
     }
 }

src/main/java/ru/nbch/indicsearchservice/util/DataSourceUpdater.java

@@ -4,8 +4,10 @@ import com.zaxxer.hikari.HikariConfig;
 import com.zaxxer.hikari.HikariDataSource;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
+import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
@@ -24,6 +26,7 @@ import org.springframework.stereotype.Component;
 import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
 import ru.nbch.indicsearchservice.config.settings.DataSourceSettings;
 import ru.nbch.indicsearchservice.event.DataSourceChangedEvent;
+import ru.nbch.indicsearchservice.exception.InternalException;
 import ru.nbch.indicsearchservice.repository.MyBatisRepository;
 import ru.nbch.indicsearchservice.repository.indic.IndicMapper;
 import ru.nbch.indicsearchservice.service.SettingsService;
@@ -173,13 +176,13 @@ public class DataSourceUpdater {
 
             SqlSessionFactory sessionFactory = sqlSessionFactoryBean.getObject();
             if (sessionFactory == null) {
-                throw new IllegalStateException("Failed to create SqlSessionFactory");
+                throw new InternalException("Failed to create SqlSessionFactory");
             }
 
             return sessionFactory;
         } catch (Exception e) {
             log.error("Failed to build SqlSessionFactory", e);
-            throw new RuntimeException("Failed to build SqlSessionFactory", e);
+            throw new InternalException("Failed to build SqlSessionFactory " + e);
         }
     }
 
@@ -201,18 +204,31 @@ public class DataSourceUpdater {
             case INDIC -> "indic";
         };
 
-        DataSourceSettings dataSourceSettings = new DataSourceSettings();
-        dataSourceSettings.setDriver(settingsService.getSettingsValueByName("datasource." + key + ".driver"));
-        dataSourceSettings.setUrl(settingsService.getSettingsValueByName("datasource." + key + ".url"));
-        dataSourceSettings.setUsername(settingsService.getSettingsValueByName("datasource." + key + ".username"));
-        dataSourceSettings.setPassword(settingsService.getSettingsValueByName("datasource." + key + ".password"));
+        Map<String, Optional<String>> fetchedSettings = settingsService.getSettingsValuesByNames(List.of(
+            "datasource." + key + ".driver",
+            "datasource." + key + ".url",
+            "datasource." + key + ".username",
+            "datasource." + key + ".password",
+            "datasource." + key + ".connection-timeout",
+            "datasource." + key + ".validation-timeout",
+            "datasource." + key + ".idle-timeout",
+            "datasource." + key + ".max-pool-size",
+            "datasource." + key + ".max-lifetime",
+            "datasource." + key + ".keep-alive-time"
+        ));
 
-        dataSourceSettings.setConnectionTimeout(Long.valueOf(settingsService.getOptionalSettingsValueByName("datasource." + key + ".connection-timeout").orElse("30000")));
-        dataSourceSettings.setValidationTimeout(Long.valueOf(settingsService.getOptionalSettingsValueByName("datasource." + key + ".validation-timeout").orElse("5000")));
-        dataSourceSettings.setIdleTimeout(Long.valueOf(settingsService.getOptionalSettingsValueByName("datasource." + key + ".idle-timeout").orElse("600000")));
-        dataSourceSettings.setMaxPoolSize(Integer.valueOf(settingsService.getOptionalSettingsValueByName("datasource." + key + ".max-pool-size").orElse("100")));
-        dataSourceSettings.setMaxLifetime(Long.valueOf(settingsService.getOptionalSettingsValueByName("datasource." + key + ".max-lifetime").orElse("1800000")));
-        dataSourceSettings.setKeepAliveTime(Long.valueOf(settingsService.getOptionalSettingsValueByName("datasource." + key + ".keep-alive-time").orElse("120000")));
+        DataSourceSettings dataSourceSettings = new DataSourceSettings();
+        dataSourceSettings.setDriver(fetchedSettings.get("datasource." + key + ".driver").orElseThrow(() -> new InternalException("Key datasource." + key + ".driver" + " was not found in SETTINGS!")));
+        dataSourceSettings.setUrl(fetchedSettings.get("datasource." + key + ".url").orElseThrow(() -> new InternalException("Key datasource." + key + ".url" + " was not found in SETTINGS!")));
+        dataSourceSettings.setUsername(fetchedSettings.get("datasource." + key + ".username").orElseThrow(() -> new InternalException("Key datasource." + key + ".username" + " was not found in SETTINGS!")));
+        dataSourceSettings.setPassword(fetchedSettings.get("datasource." + key + ".password").orElseThrow(() -> new InternalException("Key datasource." + key + ".password" + " was not found in SETTINGS!")));
+
+        dataSourceSettings.setConnectionTimeout(Long.valueOf(fetchedSettings.get("datasource." + key + ".connection-timeout").orElse("30000")));
+        dataSourceSettings.setValidationTimeout(Long.valueOf(fetchedSettings.get("datasource." + key + ".validation-timeout").orElse("5000")));
+        dataSourceSettings.setIdleTimeout(Long.valueOf(fetchedSettings.get("datasource." + key + ".idle-timeout").orElse("600000")));
+        dataSourceSettings.setMaxPoolSize(Integer.valueOf(fetchedSettings.get("datasource." + key + ".max-pool-size").orElse("100")));
+        dataSourceSettings.setMaxLifetime(Long.valueOf(fetchedSettings.get("datasource." + key + ".max-lifetime").orElse("1800000")));
+        dataSourceSettings.setKeepAliveTime(Long.valueOf(fetchedSettings.get("datasource." + key + ".keep-alive-time").orElse("120000")));
 
         settingsConsumer.accept(dataSourceSettings);
     }