INDIC search fixed

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/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/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/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,252 @@
+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 void writeExcelFile(@Nullable Path aggregatedFile, UUID taskId, Long totalRows, Map<String, TableMetaData> tableMetaDataMap) {
+        if (aggregatedFile == null) {
+            return;
+        }
+
+        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);
+        }
+    }
+
+    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,176 @@
+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 void writeJsonFile(@Nullable Path aggregatedFile,
+                              UUID taskId,
+                              SearchParameter searchParameter,
+                              Map<String, TableMetaData> tableMetaDataMap) {
+        if (aggregatedFile == null) {
+            return;
+        }
+
+        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);
+        }
+    }
+
+    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,137 @@
+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 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
+    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
+    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) {
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromAccount(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/BankruptcyTableLoader.java

@@ -0,0 +1,88 @@
+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) {
+                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,88 @@
+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) {
+                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,111 @@
+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) {
+                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,88 @@
+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) {
+                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,111 @@
+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) {
+                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,88 @@
+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) {
+                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,88 @@
+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) {
+                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,88 @@
+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) {
+                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,88 @@
+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) {
+                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,88 @@
+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) {
+                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,88 @@
+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) {
+                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,127 @@
+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) {
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuUid(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/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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,46 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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,45 @@
+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) {
+        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/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/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,14 +1,143 @@
 package ru.nbch.indicsearchservice.service;
 
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+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.http.ResponseEntity;
 import org.springframework.stereotype.Service;
+import org.springframework.util.StopWatch;
+import ru.nbch.indicsearchservice.aggregator.FileAggregator;
 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.exporter.ExcelExporter;
+import ru.nbch.indicsearchservice.exporter.JsonExporter;
+import ru.nbch.indicsearchservice.loader.FirstLevelTableLoader;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.util.TableMetaDataUtil;
 
 @Service
 public class IndicSearchService {
+    private static final Logger log = LoggerFactory.getLogger(IndicSearchService.class);
+
+    private static final boolean IS_EXPORT_AS_EXCEL = false;
+
+    private final List<FirstLevelTableLoader> tableLoaders;
+    private final List<FileAggregator> fileAggregators;
+    private final ExcelExporter excelExporter;
+    private final JsonExporter jsonExporter;
+    private final SettingsService settingsService;
+    private final TableMetaDataUtil tableMetaDataUtil;
+
+    public IndicSearchService(List<FirstLevelTableLoader> tableLoaders,
+                              List<FileAggregator> fileAggregators,
+                              ExcelExporter excelExporter,
+                              JsonExporter jsonExporter,
+                              SettingsService settingsService,
+                              TableMetaDataUtil tableMetaDataUtil) {
+        this.tableLoaders = tableLoaders;
+        this.fileAggregators = fileAggregators;
+        this.excelExporter = excelExporter;
+        this.jsonExporter = jsonExporter;
+        this.settingsService = settingsService;
+        this.tableMetaDataUtil = tableMetaDataUtil;
+    }
+
     public AddSearchJobResponseDto addSearchJob(AddSearchJobRequestDto request) {
+        UUID taskId = UUID.randomUUID();
+
+        StopWatch sw = new StopWatch();
+
+        // Подготовительный этап. Получение мета данных из БД
+        log.info("Prep step started. Getting metadata from database");
+        sw.start();
+
+        Map<String, TableMetaData> tableMetaDataMap = tableMetaDataUtil.prepareTableMetaData(request.getDataType(), request.getSearchParameter());
+        long rowLimit = Long.parseLong(settingsService.getSettingsValueByName("LimitDB"));
+
+        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(
+            taskId,
+            request.getDataType(),
+            request.getSearchParameter(),
+            request.getSearchValue(),
+            request.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(
+                taskId,
+                request.getDataType(),
+                request.getSearchParameter(),
+                request.getSearchValue(),
+                request.getMemberCode().substring(0, 6),
+                tableFileMap,
+                rowCounter))
+            .filter(Objects::nonNull)
+            .findFirst()
+            .orElse(null);
+
+        sw.stop();
+        log.info(sw.prettyPrint());
+        sw = new StopWatch();
+
+        for (Path tableFilePath : tableFileMap.values()) {
+            try {
+                Files.deleteIfExists(tableFilePath);
+            } catch (IOException e) {
+                throw new InternalException("Failed to delete file " + tableFilePath + " " + e);
+            }
+        }
+
+        // Третий этап. Экспорт агрегированного файла в JSON или XLSX
+        log.info("Third step started. Exporting aggregated file into JSON/XLSX.");
+        sw.start();
+
+        if (rowCounter.longValue() < rowLimit && !IS_EXPORT_AS_EXCEL) {
+            jsonExporter.writeJsonFile(aggregatedFile, taskId, request.getSearchParameter(), tableMetaDataMap);
+        } else {
+            tableMetaDataUtil.fillTableMetaDataWithLocalization(tableMetaDataMap);
+            excelExporter.writeExcelFile(aggregatedFile, taskId, rowCounter.longValue(), tableMetaDataMap);
+        }
+
+        sw.stop();
+        log.info(sw.prettyPrint());
+
+        try {
+            if (aggregatedFile != null) {
+                Files.deleteIfExists(aggregatedFile);
+            }
+        } catch (IOException e) {
+            throw new InternalException("Failed to delete file " + aggregatedFile + " " + e);
+        }
+
         return null;
     }
 

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

@@ -4,14 +4,15 @@ 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.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;
@@ -32,7 +33,7 @@ public class SettingsService {
 
     public String getSettingsValueByName(String name) {
         return settingsMapper.findByName(name)
-            .orElseThrow(() -> new RuntimeException("Setting with key: " + name + " was not found in database!"))
+            .orElseThrow(() -> new InternalException("Setting with key: " + name + " was not found in database!"))
             .getValue();
     }
 
@@ -41,12 +42,25 @@ public class SettingsService {
             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) {
@@ -62,7 +76,7 @@ public class SettingsService {
             try {
                 Files.createDirectories(Paths.get(newStorageDirectory.get()));
             } catch (IOException e) {
-                throw new RuntimeException(e);
+                throw new InternalException("Failed to create directory " + newStorageDirectory.get() + " " + 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);
     }

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

@@ -0,0 +1,44 @@
+package ru.nbch.indicsearchservice.util;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+public class IndicSearchCommon {
+    private static final Map<String, List<String>> CASTABLE_FIELDS = Map.ofEntries(
+        Map.entry("RU_UID", List.of("ACCT_NUM")),
+        Map.entry("RU_APPLICATION", List.of("OLD_APP_NUM")),
+        Map.entry("ID", List.of("ID_NORM")),
+        Map.entry("ACCOUNT", List.of("ACCT_NUM")),
+        Map.entry("INFORMATION", List.of("APP_NUM"))
+    );
+
+    public static Map<String, List<String>> getCastableFields() {
+        return CASTABLE_FIELDS;
+    }
+
+    public static boolean isCastableField(String tableName, String fieldName) {
+        if (tableName == null || tableName.isEmpty() || fieldName == null || fieldName.isEmpty()) {
+            return false;
+        }
+
+        if (CASTABLE_FIELDS.containsKey(tableName.toUpperCase())) {
+            return CASTABLE_FIELDS.get(tableName).contains(fieldName.toUpperCase());
+        }
+
+        return false;
+    }
+
+    public static Optional<String> getRowValue(String string, String key) {
+        return getRowValue(Arrays.asList(string.split("%%%", -1)), key);
+    }
+
+    public static Optional<String> getRowValue(List<String> stringValues, String key) {
+        int keyIndex = stringValues.indexOf(key);
+        if (keyIndex != -1) {
+            return Optional.of(stringValues.get(keyIndex + 1));
+        }
+        return Optional.empty();
+    }
+}

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

@@ -0,0 +1,129 @@
+package ru.nbch.indicsearchservice.util;
+
+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.HashMap;
+import java.util.HashSet;
+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 org.apache.ibatis.cursor.Cursor;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.exception.InternalException;
+import ru.nbch.indicsearchservice.model.LocalizationObject;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.repository.bank.LocalizationObjectMapper;
+
+@Component
+public class IndicSearchUtils {
+    private static final Set<String> REQUIRED_FIELDS = Set.of(
+        "FID",
+        "SERIAL_NUM",
+        "ACC_SERIAL_NUM",
+        "PARENT_SERIAL_NUM"
+    );
+
+    private final ApplicationSettings settings;
+    private final LocalizationObjectMapper localizationObjectMapper;
+
+    public IndicSearchUtils(ApplicationSettings settings,
+                            LocalizationObjectMapper localizationObjectMapper) {
+        this.settings = settings;
+        this.localizationObjectMapper = localizationObjectMapper;
+    }
+
+    public Path writeRowsToFile(UUID taskId,
+                                String tableName,
+                                Cursor<LinkedHashMap<String, Object>> databaseCursor,
+                                Map<String, TableMetaData> tableMetaDataMap) {
+        return writeRowsToFile(taskId, tableName, databaseCursor, null, tableMetaDataMap);
+    }
+
+    public Path writeRowsToFile(UUID taskId,
+                                String tableName,
+                                Cursor<LinkedHashMap<String, Object>> databaseCursor,
+                                Set<Integer> foundFids,
+                                Map<String, TableMetaData> tableMetaDataMap) {
+
+        Path resultFile = settings.getStorageDirectory().toPath().resolve(tableName + "_" + taskId + ".csv");
+
+        TableMetaData tableMetaData = tableMetaDataMap.get(tableName);
+        Set<String> configuredFields = tableMetaData != null ?
+            tableMetaData.getFieldMetaData().keySet() :
+            new HashSet<>();
+
+        try (BufferedWriter writer = Files.newBufferedWriter(resultFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
+            for (LinkedHashMap<String, Object> row : databaseCursor) {
+                if (foundFids != null) {
+                    Object fidValue = row.get("FID");
+                    if (fidValue != null) {
+                        foundFids.add(Integer.parseInt(fidValue.toString()));
+                    }
+                }
+
+                StringBuilder sb = new StringBuilder();
+                sb.append(tableName).append("%%%");
+
+                for (Map.Entry<String, Object> entry : row.entrySet()) {
+                    String columnName = entry.getKey();
+                    String columnNameUpper = columnName.toUpperCase();
+
+                    if (configuredFields.contains(columnName) || REQUIRED_FIELDS.contains(columnNameUpper)) {
+                        sb.append(columnNameUpper).append("%%%");
+
+                        Object columnValue = entry.getValue();
+                        if (columnValue != null) {
+                            sb.append(columnValue).append("%%%");
+                        } else {
+                            sb.append("%%%");
+                        }
+                    }
+                }
+
+                if (sb.length() >= 3) {
+                    sb.setLength(sb.length() - 3);
+                }
+
+                writer.write(sb.toString());
+                writer.newLine();
+            }
+        } catch (IOException e) {
+            throw new InternalException("Failed to write file " + resultFile + " " + e);
+        }
+
+        return resultFile;
+    }
+
+    public Map<String, Optional<String>> getOptionalLocalizationStrings(List<String> localizationCodes) {
+        if (localizationCodes == null || localizationCodes.isEmpty()) {
+            return Map.of();
+        }
+
+        Map<String, Optional<String>> resultMap = new HashMap<>();
+        for (String code : localizationCodes) {
+            if (code != null) {
+                resultMap.put(code, Optional.empty());
+            }
+        }
+
+        List<LocalizationObject> foundValues = localizationObjectMapper.findAllByCodes(localizationCodes);
+        if (foundValues == null || foundValues.isEmpty()) {
+            return resultMap;
+        }
+
+        for (LocalizationObject localization : foundValues) {
+            if (localization != null && localization.getCode() != null) {
+                resultMap.put(localization.getCode(), Optional.ofNullable(localization.getText()));
+            }
+        }
+
+        return resultMap;
+    }
+}

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

@@ -0,0 +1,62 @@
+package ru.nbch.indicsearchservice.util;
+
+import java.io.BufferedReader;
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.Objects;
+import ru.nbch.indicsearchservice.exception.InternalException;
+
+public class MovableBufferedReader implements Closeable {
+    private final BufferedReader reader;
+    private String currentLine;
+
+    public MovableBufferedReader(BufferedReader reader) {
+        this.reader = reader;
+        try {
+            this.currentLine = reader.readLine();
+        } catch (IOException e) {
+            throw new InternalException("Failed to read next line in file " + e);
+        }
+    }
+
+    public String nextLine() {
+        try {
+            this.currentLine = reader.readLine();
+        } catch (IOException e) {
+            throw new InternalException("Failed to read next line in file " + e);
+        }
+        return this.currentLine;
+    }
+
+    public BufferedReader getReader() {
+        return reader;
+    }
+
+    public String getCurrentLine() {
+        return currentLine;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o == null || getClass() != o.getClass()) return false;
+        MovableBufferedReader that = (MovableBufferedReader) o;
+        return Objects.equals(reader, that.reader) && Objects.equals(currentLine, that.currentLine);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(reader, currentLine);
+    }
+
+    @Override
+    public String toString() {
+        return "MovableBufferedReader{" +
+            "currentLine='" + currentLine + '\'' +
+            '}';
+    }
+
+    @Override
+    public void close() throws IOException {
+        this.reader.close();
+    }
+}

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

@@ -0,0 +1,233 @@
+package ru.nbch.indicsearchservice.util;
+
+import java.sql.Connection;
+import java.sql.JDBCType;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Collectors;
+import javax.sql.DataSource;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.jdbc.datasource.DataSourceUtils;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.loader.FirstLevelTableLoader;
+import ru.nbch.indicsearchservice.model.LocalizationObject;
+import ru.nbch.indicsearchservice.model.Settings;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.repository.bank.LocalizationObjectMapper;
+import ru.nbch.indicsearchservice.repository.bank.SettingsMapper;
+import ru.nbch.indicsearchservice.service.SettingsService;
+
+@Component
+public class TableMetaDataUtil {
+    private final List<FirstLevelTableLoader> tableLoaders;
+    private final SettingsService settingsService;
+    private final MapperHolder mapperHolder;
+    private final SettingsMapper settingsMapper;
+    private final LocalizationObjectMapper localizationObjectMapper;
+    private final IndicSearchUtils indicSearchUtils;
+    private final DataSource indicDataSource;
+
+    public TableMetaDataUtil(List<FirstLevelTableLoader> tableLoaders,
+                             SettingsService settingsService,
+                             MapperHolder mapperHolder,
+                             SettingsMapper settingsMapper,
+                             LocalizationObjectMapper localizationObjectMapper,
+                             IndicSearchUtils indicSearchUtils,
+                             @Qualifier("indicDataSource") DataSource indicDataSource) {
+        this.tableLoaders = tableLoaders;
+        this.settingsService = settingsService;
+        this.mapperHolder = mapperHolder;
+        this.settingsMapper = settingsMapper;
+        this.localizationObjectMapper = localizationObjectMapper;
+        this.indicSearchUtils = indicSearchUtils;
+        this.indicDataSource = indicDataSource;
+    }
+
+    public Map<String, TableMetaData> prepareTableMetaData(DataType dataType, SearchParameter searchParameter) {
+        Map<String, TableMetaData> tableMetaDataMap = new ConcurrentHashMap<>();
+
+        // Получаем список таблиц
+        Set<String> tableNames = tableLoaders.parallelStream()
+            .map(tl -> tl.getTableNamesIfSuitable(dataType, searchParameter))
+            .flatMap(Set::stream)
+            .collect(Collectors.toSet());
+
+        if (tableNames.isEmpty()) {
+            return tableMetaDataMap;
+        }
+
+        tableNames.forEach(name -> tableMetaDataMap.put(name, new TableMetaData(name)));
+
+        // Составляем массив ключей из SETTINGS
+        Map<String, String> keyToTable = new HashMap<>();
+        List<String> columnKeys = new ArrayList<>();
+        for (String table : tableNames) {
+            String key = "db.table." + table.toUpperCase() + ".fields";
+            columnKeys.add(key);
+            keyToTable.put(key, table);
+        }
+
+        // Получаем данные из SETTINGS одним запросом
+        Map<String, Optional<String>> settingsValues = settingsService.getSettingsValuesByNames(columnKeys);
+        Set<String> missingTables = new HashSet<>();
+        List<Settings> batchInsertSettings = new ArrayList<>();
+
+        for (String key : columnKeys) {
+            String table = keyToTable.get(key);
+            Optional<String> valueOpt = settingsValues.get(key);
+
+            if (valueOpt.isPresent() && StringUtils.isNotBlank(valueOpt.get())) {
+                String[] fields = valueOpt.get().split(";");
+                for (String field : fields) {
+                    tableMetaDataMap.get(table).addField(field.trim());
+                }
+            } else {
+                missingTables.add(table);
+            }
+        }
+
+        // Если найдены пропущенные значения, то добавляем их в БД
+        if (!missingTables.isEmpty()) {
+            List<LinkedHashMap<String, String>> rows =
+                mapperHolder.getIndicMapper().getTableColumnsByTableNames(new ArrayList<>(missingTables));
+
+            Map<String, List<String>> tableToColumns = new HashMap<>();
+            for (Map<String, String> row : rows) {
+                tableToColumns.computeIfAbsent(row.get("TBNAME"), t -> new ArrayList<>()).add(row.get("NAME"));
+            }
+
+            for (String table : missingTables) {
+                List<String> columns = tableToColumns.getOrDefault(table, List.of());
+                String key = "db.table." + table.toUpperCase() + ".fields";
+                String value = String.join(";", columns);
+
+                Settings newSettings = new Settings();
+                newSettings.setName(key);
+                newSettings.setValue(value);
+                batchInsertSettings.add(newSettings);
+
+                for (String column : columns) {
+                    tableMetaDataMap.get(table).addField(column.trim());
+                }
+            }
+
+            if (!batchInsertSettings.isEmpty()) {
+                settingsMapper.insertBatch(batchInsertSettings);
+            }
+        }
+
+        // Получаем размеры некоторых полей
+        for (Map.Entry<String, List<String>> entry : IndicSearchCommon.getCastableFields().entrySet()) {
+            String tableName = entry.getKey();
+            List<String> tableFields = entry.getValue();
+
+            if (!tableMetaDataMap.containsKey(tableName)) {
+                continue;
+            }
+
+            try (Connection connection = DataSourceUtils.getConnection(indicDataSource);
+                 ResultSet resultSet = connection.getMetaData().getColumns(null, null, tableName, null)) {
+                while (resultSet.next()) {
+                    String columnName = resultSet.getString("COLUMN_NAME");
+                    if (tableFields.contains(columnName) && tableMetaDataMap.get(tableName).getFieldMetaData().containsKey(columnName)) {
+                        TableMetaData.FieldMetaData foundFieldMetaData = tableMetaDataMap.get(tableName).getFieldMetaData().get(columnName);
+                        foundFieldMetaData.setJdbcType(JDBCType.valueOf(resultSet.getInt("DATA_TYPE")));
+                        foundFieldMetaData.setColumnSize(resultSet.getInt("COLUMN_SIZE"));
+                    }
+                }
+
+                DataSourceUtils.releaseConnection(connection, indicDataSource);
+            } catch (SQLException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        return tableMetaDataMap;
+    }
+
+    public void fillTableMetaDataWithLocalization(Map<String, TableMetaData> tableMetaDataMap) {
+        if (tableMetaDataMap == null || tableMetaDataMap.isEmpty()) {
+            return;
+        }
+
+        // Получаем все ключи для LOCALIZATION_OBJECT
+        Set<String> localizationKeys = new HashSet<>();
+        for (TableMetaData metaData : tableMetaDataMap.values()) {
+            String tableUpper = metaData.getTableName().toUpperCase();
+            localizationKeys.add("db.viewer.table." + tableUpper);
+
+            for (String field : metaData.getFieldMetaData().keySet()) {
+                String fieldUpper = field.toUpperCase();
+                localizationKeys.add("db.viewer." + tableUpper + ".field." + fieldUpper);
+                localizationKeys.add("db.viewer.field." + fieldUpper);
+            }
+        }
+
+        // Получаем данные из LOCALIZATION_OBJECT одним запросом
+        Map<String, Optional<String>> localizationValues = indicSearchUtils.getOptionalLocalizationStrings(new ArrayList<>(localizationKeys));
+        List<LocalizationObject> toInsertLocalizations = new ArrayList<>();
+
+        // Вставляем локализацию в tableMetaDataMap
+        for (TableMetaData metaData : tableMetaDataMap.values()) {
+            String tableUpper = metaData.getTableName().toUpperCase();
+            String tableKey = "db.viewer.table." + tableUpper;
+
+            // Локализация для таблиц
+            Optional<String> tableLoc = localizationValues.get(tableKey);
+            if (tableLoc.isPresent() && StringUtils.isNotBlank(tableLoc.get())) {
+                metaData.setTableNameLocalization(tableLoc.get());
+            } else {
+                String fallbackText = "Таблица " + tableUpper;
+                metaData.setTableNameLocalization(fallbackText);
+
+                LocalizationObject newLocalizationObject = new LocalizationObject();
+                newLocalizationObject.setCode(tableKey);
+                newLocalizationObject.setText(fallbackText);
+                toInsertLocalizations.add(newLocalizationObject);
+            }
+
+            // Локализация для полей
+            for (String field : metaData.getFieldMetaData().keySet()) {
+                String fieldUpper = field.toUpperCase();
+                String primaryKey = "db.viewer." + tableUpper + ".field." + fieldUpper;
+                String fallbackKey = "db.viewer.field." + fieldUpper;
+
+                Optional<String> primaryLoc = localizationValues.get(primaryKey);
+
+                if (primaryLoc.isPresent() && StringUtils.isNotBlank(primaryLoc.get())) {
+                    metaData.addLocalization(field, primaryLoc.get());
+                } else {
+                    Optional<String> fallbackLoc = localizationValues.get(fallbackKey);
+                    if (fallbackLoc.isPresent() && StringUtils.isNotBlank(fallbackLoc.get())) {
+                        metaData.addLocalization(field, fallbackLoc.get());
+                    } else {
+                        String fallbackText = "Поле " + fieldUpper;
+                        metaData.addLocalization(field, fallbackText);
+
+                        LocalizationObject newLocalizationObject = new LocalizationObject();
+                        newLocalizationObject.setCode(primaryKey);
+                        newLocalizationObject.setText(fallbackText);
+                        toInsertLocalizations.add(newLocalizationObject);
+                    }
+                }
+            }
+        }
+
+        // Если найдены пропущенные значения, то добавляем их в БД
+        if (!toInsertLocalizations.isEmpty()) {
+            localizationObjectMapper.insertBatch(toInsertLocalizations);
+        }
+    }
+}

src/main/resources/application.properties

@@ -12,4 +12,7 @@ app.data-source.validation-timeout=5000
 app.data-source.idle-timeout=600000
 app.data-source.max-pool-size=10
 app.data-source.max-lifetime=1800000
-app.data-source.keep-alive-time=120000
+app.data-source.keep-alive-time=120000
+
+app.storage-directory=C:\\Users\\inikolaev\\Desktop\\1
+#app.storage-directory=C:\\Users\\ivan\\Desktop\\storage

src/main/resources/mappers/bank/localization_object_mapper.xml

@@ -28,35 +28,13 @@
         FROM LOCALIZATION_OBJECT
     </sql>
 
-    <select id="findByCode" resultMap="localizationObjectResultMap">
-        <include refid="baseSelect"/>
-        WHERE CODE = #{code}
-        WITH UR
-    </select>
-
     <select id="findAllByCodes" resultMap="localizationObjectResultMap">
         <include refid="baseSelect"/>
         WHERE CODE IN
         <foreach item='code' collection='codes' open='(' separator=',' close=')'>#{code}</foreach>
+        WITH UR
     </select>
 
-    <insert id="insert" useGeneratedKeys="true" keyProperty="id">
-        INSERT INTO LOCALIZATION_OBJECT (VERSION,
-                                         CODE,
-                                         DATE_CREATED,
-                                         LAST_UPDATED,
-                                         LOC,
-                                         RELEVANCE,
-                                         TEXT)
-        VALUES (0,
-                #{code},
-                CURRENT_TIMESTAMP,
-                CURRENT_TIMESTAMP,
-                #{loc},
-                #{relevance},
-                #{text})
-    </insert>
-
     <insert id="insertBatch" useGeneratedKeys="true" keyProperty="id">
         INSERT INTO LOCALIZATION_OBJECT (VERSION,
         CODE,

src/main/resources/mappers/bank/settings_mapper.xml

@@ -27,10 +27,14 @@
         <include refid="baseSelect"/>
         WHERE NAME IN
         <foreach item='name' collection='names' open='(' separator=',' close=')'>#{name}</foreach>
-    </select>
-
-    <select id="findAll" resultMap="settingsResultMap">
-        <include refid="baseSelect"/>
         WITH UR
     </select>
+
+    <insert id="insertBatch">
+        insert into SETTINGS (VERSION, NAME, "VALUE")
+        values
+        <foreach collection="list" item="s" separator=",">
+            (0, #{s.name}, #{s.value})
+        </foreach>
+    </insert>
 </mapper>

src/test/java/ru/nbch/indicsearchservice/exporter/JsonExporterTest.java

@@ -0,0 +1,85 @@
+package ru.nbch.indicsearchservice.exporter;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.model.TableMetaData;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+
+@SpringBootTest
+class JsonExporterTest {
+    @Autowired
+    ApplicationSettings settings;
+    @Autowired
+    JsonExporter jsonExporter;
+
+    @BeforeEach
+    void setUp() {
+        settings.setStorageDirectory(Path.of("src/test/resources/storage").toFile());
+    }
+
+    @Test
+    void writeJsonFile_shouldCreateJsonFilePASSPORT() throws IOException {
+        Path aggregatedFile = settings.getStorageDirectory().toPath().resolve("test-json-aggregated.csv");
+        UUID uuid = UUID.fromString("c3805074-e840-4d4e-bfa3-eee1fefd4907");
+
+        TableMetaData ruUidTableTableMetaData = new TableMetaData("RU_UID");
+        ruUidTableTableMetaData.addField("FID");
+        ruUidTableTableMetaData.addField("SERIAL_NUM");
+        TableMetaData ruApplicationTableTableMetaData = new TableMetaData("RU_APPLICATION");
+        ruApplicationTableTableMetaData.addField("FID");
+        ruApplicationTableTableMetaData.addField("SERIAL_NUM");
+
+        Map<String, TableMetaData> tableMetaDataMap = new HashMap<>();
+        tableMetaDataMap.put("RU_UID", ruUidTableTableMetaData);
+        tableMetaDataMap.put("RU_APPLICATION", ruApplicationTableTableMetaData);
+
+        jsonExporter.writeJsonFile(aggregatedFile, uuid, SearchParameter.PASSPORT, tableMetaDataMap);
+
+        Path resultFile = settings.getStorageDirectory().toPath().resolve("c3805074-e840-4d4e-bfa3-eee1fefd4907.json");
+        List<String> resultFileStrings = Files.readAllLines(resultFile);
+
+        Files.deleteIfExists(resultFile);
+
+        assertThat(resultFileStrings.getFirst())
+            .isEqualTo("{\"datasheets\":[[{\"table_name\":\"RU_UID\",\"field_data\":[{\"key\":\"FID\",\"value\":\"1\"},{\"key\":\"SERIAL_NUM\",\"value\":\"11\"}],\"related_data\":[]},{\"table_name\":\"RU_UID\",\"field_data\":[{\"key\":\"FID\",\"value\":\"1\"},{\"key\":\"SERIAL_NUM\",\"value\":\"21\"}],\"related_data\":[{\"table_name\":\"RU_TRADE\",\"field_data\":[],\"related_data\":[]}]}],[{\"table_name\":\"RU_APPLICATION\",\"field_data\":[{\"key\":\"FID\",\"value\":\"2\"},{\"key\":\"SERIAL_NUM\",\"value\":\"12\"}],\"related_data\":[]}],[{\"table_name\":\"RU_APPLICATION\",\"field_data\":[{\"key\":\"FID\",\"value\":\"3\"},{\"key\":\"SERIAL_NUM\",\"value\":\"22\"}],\"related_data\":[]}]]}");
+    }
+
+    @Test
+    void writeJsonFile_shouldCreateJsonFileUUID() throws IOException {
+        Path aggregatedFile = settings.getStorageDirectory().toPath().resolve("test-json-aggregated.csv");
+        UUID uuid = UUID.fromString("c3805074-e840-4d4e-bfa3-eee1fefd4907");
+
+        TableMetaData ruUidTableTableMetaData = new TableMetaData("RU_UID");
+        ruUidTableTableMetaData.addField("FID");
+        ruUidTableTableMetaData.addField("SERIAL_NUM");
+        TableMetaData ruApplicationTableTableMetaData = new TableMetaData("RU_APPLICATION");
+        ruApplicationTableTableMetaData.addField("FID");
+        ruApplicationTableTableMetaData.addField("SERIAL_NUM");
+
+        Map<String, TableMetaData> tableMetaDataMap = new HashMap<>();
+        tableMetaDataMap.put("RU_UID", ruUidTableTableMetaData);
+        tableMetaDataMap.put("RU_APPLICATION", ruApplicationTableTableMetaData);
+
+        jsonExporter.writeJsonFile(aggregatedFile, uuid, SearchParameter.UUID, tableMetaDataMap);
+
+        Path resultFile = settings.getStorageDirectory().toPath().resolve("c3805074-e840-4d4e-bfa3-eee1fefd4907.json");
+        List<String> resultFileStrings = Files.readAllLines(resultFile);
+
+        Files.deleteIfExists(resultFile);
+
+        assertThat(resultFileStrings.getFirst())
+            .isEqualTo("{\"datasheets\":[[{\"table_name\":\"RU_UID\",\"field_data\":[{\"key\":\"FID\",\"value\":\"1\"},{\"key\":\"SERIAL_NUM\",\"value\":\"11\"}],\"related_data\":[]}],[{\"table_name\":\"RU_UID\",\"field_data\":[{\"key\":\"FID\",\"value\":\"1\"},{\"key\":\"SERIAL_NUM\",\"value\":\"21\"}],\"related_data\":[{\"table_name\":\"RU_TRADE\",\"field_data\":[],\"related_data\":[]}]}],[{\"table_name\":\"RU_APPLICATION\",\"field_data\":[{\"key\":\"FID\",\"value\":\"2\"},{\"key\":\"SERIAL_NUM\",\"value\":\"12\"}],\"related_data\":[]}],[{\"table_name\":\"RU_APPLICATION\",\"field_data\":[{\"key\":\"FID\",\"value\":\"3\"},{\"key\":\"SERIAL_NUM\",\"value\":\"22\"}],\"related_data\":[]}]]}");
+    }
+}

src/test/resources/application.properties

@@ -0,0 +1,18 @@
+spring.application.name=indic-search-service
+
+logging.level.org.springframework.boot.context.config=DEBUG
+
+# Database properties
+app.data-source.driver=com.ibm.db2.jcc.DB2Driver
+app.data-source.username=ros9lk
+app.data-source.password=ros9lk
+app.data-source.url=jdbc:db2://10.230.227.21:2667/DEVSUPPL:currentSchema=ROS9LK;
+app.data-source.connection-timeout=40000
+app.data-source.validation-timeout=5000
+app.data-source.idle-timeout=600000
+app.data-source.max-pool-size=10
+app.data-source.max-lifetime=1800000
+app.data-source.keep-alive-time=120000
+
+app.storage-directory=C:\\Users\\inikolaev\\Desktop\\1
+#app.storage-directory=C:\\Users\\ivan\\Desktop\\storage

src/test/resources/storage/test-json-aggregated.csv

@@ -0,0 +1,6 @@
+RU_UID%%%FID%%%1%%%SERIAL_NUM%%%11%%%
+RU_UID%%%FID%%%1%%%SERIAL_NUM%%%21%%%
+RU_TRADE%%%FID%%%1%%%SERIAL_NUM%%%31%%%ACC_SERIAL_NUM%%%21%%%
+RU_APPLICATION%%%FID%%%2%%%SERIAL_NUM%%%12%%%
+RU_APPLICATION%%%FID%%%3%%%SERIAL_NUM%%%22%%%
+EOF