new search parameters added

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

@@ -9,13 +9,11 @@ import ru.nbch.indicsearchservice.model.enums.DataType;
 import ru.nbch.indicsearchservice.model.enums.SearchParameter;
 
 public interface FileAggregator {
-    List<DataType> getSuitableDataTypes();
+    Path aggregateFiles(UUID taskId,
-    List<SearchParameter> getSuitableSearchParameters();
+                        DataType dataType,
-    List<String> getRequiredTables();
+                        SearchParameter searchParameter,
-
+                        String searchValue,
-    default boolean isSuitableForDataTypeAndSearchParameter(DataType dataType, SearchParameter searchParameter) {
+                        String memberCode,
-        return getSuitableDataTypes().contains(dataType) && getSuitableSearchParameters().contains(searchParameter);
+                        Map<String, Path> tableFileMap,
-    }
+                        MutableLong rowCounter);
-
-    Path aggregateFiles(Map<String, Path> tableFileMap, String memberCode, MutableLong rowCounter, UUID taskId);
 }

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

@@ -52,7 +52,12 @@ public class FileAggregatorCommon {
         "RU_ALL_ARREARS"
     );
 
-    void aggregateRuUidFiles(BufferedWriter aggregatedFileWriter, Map<String, Path> tableFileMap, String memberCode, MutableLong rowCounter) {
+    void aggregateRuUidFiles(BufferedWriter aggregatedFileWriter,
+                             Map<String, Path> tableFileMap,
+                             String memberCode,
+                             String acctNum,
+                             String uuid,
+                             MutableLong rowCounter) {
         try (BufferedReader ruUidFileReader = Files.newBufferedReader(tableFileMap.get("RU_UID"))) {
             Map<String, MovableBufferedReader> childTablesReadersMap = new LinkedHashMap<>();
             for (String tableName : RU_UID_CHILD_TABLES) {
@@ -75,6 +80,21 @@ public class FileAggregatorCommon {
                     continue;
                 }
 
+                if (acctNum != null) {
+                    Optional<String> foundAcctNum = IndicSearchCommon.getRowValue(lineList, "ACCT_NUM");
+
+                    if (foundAcctNum.isPresent() && !foundAcctNum.get().equals(acctNum)) {
+                        continue;
+                    }
+                }
+                if (uuid != null) {
+                    Optional<String> foundUuid = IndicSearchCommon.getRowValue(lineList, "UUID");
+
+                    if (foundUuid.isPresent() && !foundUuid.get().equals(uuid)) {
+                        continue;
+                    }
+                }
+
                 aggregatedFileWriter.write(ruUidLine);
                 aggregatedFileWriter.newLine();
                 rowCounter.increment();

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

@@ -1,95 +0,0 @@
-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.model.enums.DataType;
-import ru.nbch.indicsearchservice.model.enums.SearchParameter;
-import ru.nbch.indicsearchservice.util.IndicSearchCommon;
-
-@Component
-public class GutdfFidFileAggregator 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 GutdfFidFileAggregator(ApplicationSettings settings,
-                                  FileAggregatorCommon fileAggregatorCommon) {
-        this.settings = settings;
-        this.fileAggregatorCommon = fileAggregatorCommon;
-    }
-
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
-    @Override
-    public List<String> getRequiredTables() {
-        return REQUIRED_TABLES;
-    }
-
-    @Override
-    public Path aggregateFiles(Map<String, Path> tableFileMap, String memberCode, MutableLong rowCounter, UUID taskId) {
-        Path aggregatedFile = settings.getStorageDirectory().toPath().resolve("AGGREGATED-" + taskId + ".csv");
-
-        try (BufferedWriter aggregatedFileWriter = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
-            for (String tableName : getRequiredTables()) {
-                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 RuntimeException(e);
-                    }
-                }
-            }
-
-            aggregatedFileWriter.write("EOF");
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-
-        return aggregatedFile;
-    }
-}

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

@@ -0,0 +1,92 @@
+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.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, null, null, 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 RuntimeException(e);
+                            }
+                        }
+                    }
+
+                    aggregatedFileWriter.write("EOF");
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+
+                return aggregatedFile;
+            }
+        }
+
+        return null;
+    }
+}

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

@@ -0,0 +1,77 @@
+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.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;
+                        }
+
+                        if (searchParameter == SearchParameter.APPLICATION_NUMBER && searchValue != null) {
+                            searchValue = searchValue.length() > 38 ? searchValue.substring(0, 38) : searchValue;
+
+                            Optional<String> foundApplicationNumber = IndicSearchCommon.getRowValue(line, "APPLICATION_NUMBER");
+
+                            if (foundApplicationNumber.isPresent() && !foundApplicationNumber.get().equals(searchValue)) {
+                                continue;
+                            }
+                        }
+                        if (searchParameter == SearchParameter.OLD_APP_NUM && searchValue != null) {
+                            Optional<String> foundOldAppNum = IndicSearchCommon.getRowValue(line, "OLD_APP_NUM");
+
+                            if (foundOldAppNum.isPresent() && !foundOldAppNum.get().equals(searchValue)) {
+                                continue;
+                            }
+                        }
+
+                        aggregatedFileWriter.write(line);
+                        aggregatedFileWriter.newLine();
+                        rowCounter.increment();
+                    }
+
+                    aggregatedFileWriter.write("EOF");
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+
+                return aggregatedFile;
+            }
+        }
+
+        return null;
+    }
+}

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

@@ -0,0 +1,55 @@
+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.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+import ru.nbch.indicsearchservice.util.IndicSearchCommon;
+
+@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)) {
+                    if (searchParameter == SearchParameter.UUID) {
+                        fileAggregatorCommon.aggregateRuUidFiles(aggregatedFileWriter, tableFileMap, memberCode, null, searchValue, rowCounter);
+                    } else {
+                        fileAggregatorCommon.aggregateRuUidFiles(aggregatedFileWriter, tableFileMap, memberCode, searchValue, null, rowCounter);
+                    }
+
+                    aggregatedFileWriter.write("EOF");
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+
+                return aggregatedFile;
+            }
+        }
+
+        return null;
+    }
+}

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

@@ -41,7 +41,11 @@ public class ExcelExporter implements Exporter {
         this.settings = settings;
     }
 
-    public void writeExcelFile(Path aggregatedFile, UUID taskId, Long totalRows) {
+    public void writeExcelFile(@Nullable Path aggregatedFile, UUID taskId, Long totalRows) {
+        if (aggregatedFile == null) {
+            return;
+        }
+
         Path excelFile = settings.getStorageDirectory().toPath().resolve(taskId.toString() + ".xlsx");
 
         try (OutputStream os = Files.newOutputStream(excelFile);

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

@@ -1,5 +1,6 @@
 package ru.nbch.indicsearchservice.exporter;
 
+import jakarta.annotation.Nullable;
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.nio.file.Files;
@@ -30,7 +31,11 @@ public class JsonExporter implements Exporter {
         this.jsonMapper = jsonMapper;
     }
 
-    public void writeJsonFile(Path aggregatedFile, UUID taskId) {
+    public void writeJsonFile(@Nullable Path aggregatedFile, UUID taskId) {
+        if (aggregatedFile == null) {
+            return;
+        }
+
         Path jsonFile = settings.getStorageDirectory().toPath().resolve(taskId.toString() + ".json");
 
         try (BufferedReader reader = Files.newBufferedReader(aggregatedFile);

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

@@ -0,0 +1,16 @@
+package ru.nbch.indicsearchservice.loader;
+
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.UUID;
+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);
+}

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

@@ -0,0 +1,71 @@
+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.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+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
+    @Transactional(readOnly = true)
+    public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.OGRN || searchParameter == SearchParameter.PASSPORT) {
+                Set<Integer> foundFids = new HashSet<>();
+
+                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 RuntimeException(e);
+                }
+
+                tableLoaders.parallelStream().forEach(tl -> tl.searchById(
+                    taskId,
+                    dataType,
+                    searchParameter,
+                    foundFids,
+                    memberCode,
+                    tableFileMap
+                ));
+            }
+        }
+    }
+}

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

@@ -1,9 +1,14 @@
 package ru.nbch.indicsearchservice.loader;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
+import org.apache.ibatis.cursor.Cursor;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 import ru.nbch.indicsearchservice.model.enums.DataType;
@@ -12,7 +17,7 @@ import ru.nbch.indicsearchservice.util.IndicSearchUtils;
 import ru.nbch.indicsearchservice.util.MapperHolder;
 
 @Component
-public class RuApplicationTableLoader implements TableLoader {
+public class RuApplicationTableLoader implements FirstLevelTableLoader, TableLoaderForId {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +27,6 @@ public class RuApplicationTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_APPLICATION";
@@ -39,7 +34,37 @@ public class RuApplicationTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuApplication(fidSet), taskId);
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.APPLICATION_NUMBER || searchParameter == SearchParameter.OLD_APP_NUM) {
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByMemberCodeFromRuApplication(memberCode)) {
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+                } catch (IOException e) {
+                    throw new RuntimeException(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));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
+        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));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
     }
 }

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

@@ -1,9 +1,14 @@
 package ru.nbch.indicsearchservice.loader;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
+import org.apache.ibatis.cursor.Cursor;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 import ru.nbch.indicsearchservice.model.enums.DataType;
@@ -12,7 +17,7 @@ import ru.nbch.indicsearchservice.util.IndicSearchUtils;
 import ru.nbch.indicsearchservice.util.MapperHolder;
 
 @Component
-public class RuBankruptcyTableLoader implements TableLoader {
+public class RuBankruptcyTableLoader implements FirstLevelTableLoader, TableLoaderForId {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +27,6 @@ public class RuBankruptcyTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_BANKRUPTCY";
@@ -39,7 +34,31 @@ public class RuBankruptcyTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcy(fidSet), taskId);
+        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));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
+        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));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
     }
 }

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

@@ -1,9 +1,14 @@
 package ru.nbch.indicsearchservice.loader;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
+import org.apache.ibatis.cursor.Cursor;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 import ru.nbch.indicsearchservice.model.enums.DataType;
@@ -12,7 +17,7 @@ import ru.nbch.indicsearchservice.util.IndicSearchUtils;
 import ru.nbch.indicsearchservice.util.MapperHolder;
 
 @Component
-public class RuCapabilityTableLoader implements TableLoader {
+public class RuCapabilityTableLoader implements FirstLevelTableLoader, TableLoaderForId {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +27,6 @@ public class RuCapabilityTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_CAPABILITY";
@@ -39,7 +34,31 @@ public class RuCapabilityTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCapability(fidSet), taskId);
+        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));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
+        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));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
     }
 }

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

@@ -1,9 +1,14 @@
 package ru.nbch.indicsearchservice.loader;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
+import org.apache.ibatis.cursor.Cursor;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 import ru.nbch.indicsearchservice.model.enums.DataType;
@@ -12,7 +17,7 @@ import ru.nbch.indicsearchservice.util.IndicSearchUtils;
 import ru.nbch.indicsearchservice.util.MapperHolder;
 
 @Component
-public class RuDebtBurdenInfoTableLoader implements TableLoader {
+public class RuDebtBurdenInfoTableLoader implements FirstLevelTableLoader, TableLoaderForId {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +27,6 @@ public class RuDebtBurdenInfoTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_DEBT_BURDEN_INFO";
@@ -39,7 +34,31 @@ public class RuDebtBurdenInfoTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuDebtBurdenInfo(fidSet), taskId);
+        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));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
+        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));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
     }
 }

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

@@ -1,9 +1,14 @@
 package ru.nbch.indicsearchservice.loader;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
+import org.apache.ibatis.cursor.Cursor;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 import ru.nbch.indicsearchservice.model.enums.DataType;
@@ -12,7 +17,7 @@ import ru.nbch.indicsearchservice.util.IndicSearchUtils;
 import ru.nbch.indicsearchservice.util.MapperHolder;
 
 @Component
-public class RuObligPartTakeTableLoader implements TableLoader {
+public class RuObligPartTakeTableLoader implements FirstLevelTableLoader, TableLoaderForId {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +27,6 @@ public class RuObligPartTakeTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_OBLIGPARTTAKE";
@@ -39,7 +34,31 @@ public class RuObligPartTakeTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligPartTake(fidSet), taskId);
+        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));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
+        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));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
     }
 }

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

@@ -1,9 +1,14 @@
 package ru.nbch.indicsearchservice.loader;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
+import org.apache.ibatis.cursor.Cursor;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 import ru.nbch.indicsearchservice.model.enums.DataType;
@@ -12,7 +17,7 @@ import ru.nbch.indicsearchservice.util.IndicSearchUtils;
 import ru.nbch.indicsearchservice.util.MapperHolder;
 
 @Component
-public class RuOtherLegalTableLoader implements TableLoader {
+public class RuOtherLegalTableLoader implements FirstLevelTableLoader, TableLoaderForId {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +27,6 @@ public class RuOtherLegalTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_OTHERLEGAL";
@@ -39,7 +34,31 @@ public class RuOtherLegalTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuOtherLegal(fidSet), taskId);
+        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));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
+        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));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
     }
 }

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

@@ -1,9 +1,14 @@
 package ru.nbch.indicsearchservice.loader;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+import java.util.Arrays;
+import java.util.LinkedHashMap;
+import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
+import org.apache.ibatis.cursor.Cursor;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
 import ru.nbch.indicsearchservice.model.enums.DataType;
@@ -12,7 +17,7 @@ import ru.nbch.indicsearchservice.util.IndicSearchUtils;
 import ru.nbch.indicsearchservice.util.MapperHolder;
 
 @Component
-public class RuSettledTableLoader implements TableLoader {
+public class RuSettledTableLoader implements FirstLevelTableLoader, TableLoaderForId {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +27,6 @@ public class RuSettledTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_SETTLED";
@@ -39,7 +34,31 @@ public class RuSettledTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSettled(fidSet), taskId);
+        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));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
+        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));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
     }
 }

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

@@ -1,35 +1,36 @@
 package ru.nbch.indicsearchservice.loader;
 
+import java.io.IOException;
 import java.nio.file.Path;
+import java.util.Arrays;
+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 java.util.stream.Collectors;
+import org.apache.ibatis.cursor.Cursor;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
+import ru.nbch.indicsearchservice.loader.subtable.RuUidSubTableLoader;
 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 RuUidTableLoader implements TableLoader {
+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) {
+                            IndicSearchUtils indicSearchUtils,
+                            List<RuUidSubTableLoader> ruUidSubTableLoaders) {
         this.mapperHolder = mapperHolder;
         this.indicSearchUtils = indicSearchUtils;
-    }
+        this.ruUidSubTableLoaders = ruUidSubTableLoaders;
-
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
     }
 
     @Override
@@ -39,7 +40,40 @@ public class RuUidTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchBy(UUID taskId, DataType dataType, SearchParameter searchParameter, String searchValue, String memberCode, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuUid(fidSet), taskId);
+        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
+            if (searchParameter == SearchParameter.UUID || searchParameter == SearchParameter.ACCT_NUM) {
+                try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByMemberCodeFromRuUid(memberCode)) {
+                    Set<Integer> foundFids = new HashSet<>();
+                    tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor, foundFids));
+                    ruUidSubTableLoaders.parallelStream().forEach(tl -> tl.searchByRuUidFid(taskId, foundFids, tableFileMap));
+                } catch (IOException e) {
+                    throw new RuntimeException(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));
+                    ruUidSubTableLoaders.parallelStream().forEach(tl -> tl.searchByRuUidFid(taskId, fids, tableFileMap));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+    @Override
+    @Transactional(readOnly = true)
+    public void searchById(UUID taskId, DataType dataType, SearchParameter searchParameter, Set<Integer> fids, String memberCode, Map<String, Path> tableFileMap) {
+        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));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
     }
 }

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

@@ -1,20 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
 import java.nio.file.Path;
-import java.util.List;
+import java.util.Map;
-import java.util.Set;
 import java.util.UUID;
 import ru.nbch.indicsearchservice.model.enums.DataType;
 import ru.nbch.indicsearchservice.model.enums.SearchParameter;
 
 public interface TableLoader {
-    List<DataType> getSuitableDataTypes();
-    List<SearchParameter> getSuitableSearchParameters();
     String getTableName();
-
-    default boolean isSuitableForDataTypeAndSearchParameter(DataType dataType, SearchParameter searchParameter) {
-        return getSuitableDataTypes().contains(dataType) && getSuitableSearchParameters().contains(searchParameter);
-    }
-
-    Path searchByFid(Set<Integer> fids, UUID taskId);
 }

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

@@ -0,0 +1,12 @@
+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.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);
+}

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuAccountAmtTableLoader implements TableLoader {
+public class RuAccountAmtTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuAccountAmtTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_ACCOUNT_AMT";
@@ -39,7 +30,11 @@ public class RuAccountAmtTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAccountAmt(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAccountAmt(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuAcquirerIndividTableLoader implements TableLoader {
+public class RuAcquirerIndividTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuAcquirerIndividTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_ACQUIRERINDIVID";
@@ -39,7 +30,11 @@ public class RuAcquirerIndividTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerIndivid(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAcquirerIndivid(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuAcquirerLegalTableLoader implements TableLoader {
+public class RuAcquirerLegalTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuAcquirerLegalTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_ACQUIRERLEGAL";
@@ -39,7 +30,11 @@ public class RuAcquirerLegalTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerLegal(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAcquirerLegal(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuAllArrearsTableLoader implements TableLoader {
+public class RuAllArrearsTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuAllArrearsTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_ALL_ARREARS";
@@ -39,7 +30,11 @@ public class RuAllArrearsTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAllArrears(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAllArrears(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuAmendmentTableLoader implements TableLoader {
+public class RuAmendmentTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuAmendmentTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_AMENDMENT";
@@ -39,7 +30,11 @@ public class RuAmendmentTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAmendment(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAmendment(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuAmountInfoTableLoader implements TableLoader {
+public class RuAmountInfoTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuAmountInfoTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_AMOUNT_INFO";
@@ -39,7 +30,11 @@ public class RuAmountInfoTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAmountInfo(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuAmountInfo(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuArrearTableLoader implements TableLoader {
+public class RuArrearTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuArrearTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_ARREAR";
@@ -39,7 +30,11 @@ public class RuArrearTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuArrear(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuArrear(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuBankruptcyBlocksTableLoader implements TableLoader {
+public class RuBankruptcyBlocksTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuBankruptcyBlocksTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_BANKRUPTCY_BLOCKS";
@@ -39,7 +30,11 @@ public class RuBankruptcyBlocksTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcyBlocks(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuBankruptcyBlocks(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuCoborrowerTableLoader implements TableLoader {
+public class RuCoborrowerTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuCoborrowerTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_COBORROWER";
@@ -39,7 +30,11 @@ public class RuCoborrowerTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCoborrower(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCoborrower(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuCollatInsuredTableLoader implements TableLoader {
+public class RuCollatInsuredTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuCollatInsuredTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_COLLATINSURED";
@@ -39,7 +30,11 @@ public class RuCollatInsuredTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollatInsured(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCollatInsured(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuCollatRepayTableLoader implements TableLoader {
+public class RuCollatRepayTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuCollatRepayTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_COLLATREPAY";
@@ -39,7 +30,11 @@ public class RuCollatRepayTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollatRepay(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCollatRepay(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuCollateralBlocksTableLoader implements TableLoader {
+public class RuCollateralBlocksTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuCollateralBlocksTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_COLLATERAL_BLOCKS";
@@ -39,7 +30,11 @@ public class RuCollateralBlocksTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollateralBlocks(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCollateralBlocks(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuCollateralTableLoader implements TableLoader {
+public class RuCollateralTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuCollateralTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_COLLATERAL";
@@ -39,7 +30,11 @@ public class RuCollateralTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollateral(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuCollateral(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuContractTermsChangesTableLoader implements TableLoader {
+public class RuContractTermsChangesTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuContractTermsChangesTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_CONTRACT_TERMS_CHANGES";
@@ -39,7 +30,11 @@ public class RuContractTermsChangesTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuContractTermsChanges(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuContractTermsChanges(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuDueArrearTableLoader implements TableLoader {
+public class RuDueArrearTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuDueArrearTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_DUEARREAR";
@@ -39,7 +30,11 @@ public class RuDueArrearTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuDueArrear(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuDueArrear(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuFundDateTableLoader implements TableLoader {
+public class RuFundDateTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuFundDateTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_FUNDDATE";
@@ -39,7 +30,11 @@ public class RuFundDateTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuFundDate(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuFundDate(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuGuaranteeRepayTableLoader implements TableLoader {
+public class RuGuaranteeRepayTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuGuaranteeRepayTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_GUARANTEEREPAY";
@@ -39,7 +30,11 @@ public class RuGuaranteeRepayTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuGuaranteeRepay(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuGuaranteeRepay(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuGuarantorTableLoader implements TableLoader {
+public class RuGuarantorTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuGuarantorTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_GUARANTOR";
@@ -39,7 +30,11 @@ public class RuGuarantorTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuGuarantor(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuGuarantor(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuIndepGuarantorTableLoader implements TableLoader {
+public class RuIndepGuarantorTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuIndepGuarantorTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_INDEPGUARANTOR";
@@ -39,7 +30,11 @@ public class RuIndepGuarantorTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuIndepGuarantor(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuIndepGuarantor(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuLegalRecordTableLoader implements TableLoader {
+public class RuLegalRecordTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuLegalRecordTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_LEGALRECORD";
@@ -39,7 +30,11 @@ public class RuLegalRecordTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuLegalRecord(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuLegalRecord(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuMonthAverPaymtTableLoader implements TableLoader {
+public class RuMonthAverPaymtTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuMonthAverPaymtTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_MONTHAVERPAYMT";
@@ -39,7 +30,11 @@ public class RuMonthAverPaymtTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuMonthAverPaymt(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuMonthAverPaymt(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuObligAccountTableLoader implements TableLoader {
+public class RuObligAccountTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuObligAccountTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_OBLIGACCOUNT";
@@ -39,7 +30,11 @@ public class RuObligAccountTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligAccount(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligAccount(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuObligTerminationTableLoader implements TableLoader {
+public class RuObligTerminationTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuObligTerminationTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_OBLIGTERMINATION";
@@ -39,7 +30,11 @@ public class RuObligTerminationTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligTermination(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligTermination(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuObligsRcBankruptTableLoader implements TableLoader {
+public class RuObligsRcBankruptTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuObligsRcBankruptTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_OBLIGSRCBANKRUPT";
@@ -39,7 +30,11 @@ public class RuObligsRcBankruptTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcBankrupt(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligsRcBankrupt(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuObligsRcLiquidTableLoader implements TableLoader {
+public class RuObligsRcLiquidTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuObligsRcLiquidTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_OBLIGSRCLIQUID";
@@ -39,7 +30,11 @@ public class RuObligsRcLiquidTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcLiquid(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuObligsRcLiquid(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuOverallvalTableLoader implements TableLoader {
+public class RuOverallvalTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -23,16 +24,6 @@ public class RuOverallvalTableLoader implements TableLoader {
 
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_OVERALLVAL";
@@ -40,7 +31,11 @@ public class RuOverallvalTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuOverallval(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuOverallval(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuPastDueArrearTableLoader implements TableLoader {
+public class RuPastDueArrearTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuPastDueArrearTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_PASTDUEARREAR";
@@ -39,7 +30,11 @@ public class RuPastDueArrearTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuPastDueArrear(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuPastDueArrear(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuPaymtConditionTableLoader implements TableLoader {
+public class RuPaymtConditionTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuPaymtConditionTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_PAYMT_CONDITION";
@@ -39,7 +30,11 @@ public class RuPaymtConditionTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuPaymtCondition(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuPaymtCondition(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuPaymtTableLoader implements TableLoader {
+public class RuPaymtTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuPaymtTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_PAYMT";
@@ -39,7 +30,11 @@ public class RuPaymtTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuPaymt(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuPaymt(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuServiceCoTableLoader implements TableLoader {
+public class RuServiceCoTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuServiceCoTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_SERVICECO";
@@ -39,7 +30,11 @@ public class RuServiceCoTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuServiceCo(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuServiceCo(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuSourceNonMonetObligTableLoader implements TableLoader {
+public class RuSourceNonMonetObligTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuSourceNonMonetObligTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_SOURCENONMONETOBLIG";
@@ -39,7 +30,11 @@ public class RuSourceNonMonetObligTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSourceNonMonetOblig(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuSourceNonMonetOblig(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuSubjectNonMonetObligTableLoader implements TableLoader {
+public class RuSubjectNonMonetObligTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuSubjectNonMonetObligTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_SUBJECTNONMONETOBLIG";
@@ -39,7 +30,11 @@ public class RuSubjectNonMonetObligTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSubjectNonMonetOblig(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuSubjectNonMonetOblig(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuSubmitHoldTableLoader implements TableLoader {
+public class RuSubmitHoldTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuSubmitHoldTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_SUBMITHOLD";
@@ -39,7 +30,11 @@ public class RuSubmitHoldTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSubmitHold(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuSubmitHold(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

@@ -1,18 +1,19 @@
-package ru.nbch.indicsearchservice.loader;
+package ru.nbch.indicsearchservice.loader.subtable;
 
+import java.io.IOException;
 import java.nio.file.Path;
-import java.util.List;
+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.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 RuTradeTableLoader implements TableLoader {
+public class RuTradeTableLoader implements RuUidSubTableLoader {
     private final MapperHolder mapperHolder;
     private final IndicSearchUtils indicSearchUtils;
 
@@ -22,16 +23,6 @@ public class RuTradeTableLoader implements TableLoader {
         this.indicSearchUtils = indicSearchUtils;
     }
 
-    @Override
-    public List<DataType> getSuitableDataTypes() {
-        return List.of(DataType.GUTDF, DataType.RUTDF);
-    }
-
-    @Override
-    public List<SearchParameter> getSuitableSearchParameters() {
-        return List.of(SearchParameter.FID);
-    }
-
     @Override
     public String getTableName() {
         return "RU_TRADE";
@@ -39,7 +30,11 @@ public class RuTradeTableLoader implements TableLoader {
 
     @Override
     @Transactional(readOnly = true)
-    public Path searchByFid(Set<Integer> fids, UUID taskId) {
+    public void searchByRuUidFid(UUID taskId, Set<Integer> fids, Map<String, Path> tableFileMap) {
-        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuTrade(fidSet), taskId);
+        try (Cursor<LinkedHashMap<String, Object>> cursor = mapperHolder.getIndicMapper().findAllByFidsFromRuTrade(fids)) {
+            tableFileMap.put(getTableName(), indicSearchUtils.writeRowsToFile(taskId, getTableName(), cursor));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
     }
 }

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

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

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

@@ -0,0 +1,10 @@
+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.loader.TableLoader;
+
+public interface SubTableLoader extends TableLoader {
+}

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

@@ -11,212 +11,52 @@ import ru.nbch.indicsearchservice.repository.MyBatisRepository;
 public interface IndicMapper extends MyBatisRepository {
     List<LinkedHashMap<String, String>> getTableColumnsByTableNames(List<String> tables);
 
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuUid(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuUid(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuTrade(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuApplication(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuApplication(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuObligPartTake(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAccountAmt(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuBankruptcy(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAcquirerIndivid(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuSettled(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAcquirerLegal(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuOtherLegal(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAllArrears(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCapability(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAmendment(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuDebtBurdenInfo(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAmountInfo(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuArrear(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuBankruptcy(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuBankruptcyBlocks(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCapability(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCoborrower(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCollateral(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCollateralBlocks(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCollatInsured(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCollatRepay(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuContractTermsChanges(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuDebtBurdenInfo(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuDueArrear(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuFundDate(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuGuaranteeRepay(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuGuarantor(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuIndepGuarantor(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuLegalRecord(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuMonthAverPaymt(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuObligAccount(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuObligPartTake(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuObligsRcBankrupt(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuObligsRcLiquid(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuObligTermination(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuOtherLegal(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuOverallval(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuPastDueArrear(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuPaymtCondition(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuPaymt(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuServiceCo(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuSettled(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuSourceNonMonetOblig(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuSubjectNonMonetOblig(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuSubmitHold(Set<Integer> fids);
 
-    List<LinkedHashMap<String, Object>> findAllByAcctNumAndMemberCodeFromRuUid(String columns, String acctNum, String memberCode);
+    Cursor<LinkedHashMap<String, Object>> findAllByMemberCodeFromRuUid(String memberCode);
-    Cursor<LinkedHashMap<String, Object>> findAllByAcctNumAndMemberCodeFromRuUidCursor(String columns, String acctNum, String memberCode);
+    Cursor<LinkedHashMap<String, Object>> findAllByMemberCodeFromRuApplication(String memberCode);
-    List<LinkedHashMap<String, Object>> findAllByApplicationNumberAndMemberCodeFromRuApplication(String columns, String applicationNumber, String memberCode);
+    Cursor<LinkedHashMap<String, Object>> findFidsByOgrnFromId(String idNorm);
-    Cursor<LinkedHashMap<String, Object>> findAllByApplicationNumberAndMemberCodeFromRuApplicationCursor(String columns, String applicationNumber, String memberCode);
+    Cursor<LinkedHashMap<String, Object>> findFidsByPassportFromId(String idNorm);
-    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);
 
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuTrade(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuTrade(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuTradeCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAccountAmt(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAccountAmt(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAcquirerIndivid(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAccountAmtCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAcquirerLegal(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCoborrower(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAllArrears(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCoborrowerCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAmendment(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPaymtCondition(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuAmountInfo(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPaymtConditionCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuArrear(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuOverallval(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuBankruptcyBlocks(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuOverallvalCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCoborrower(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAmendment(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCollateral(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuAmendmentCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCollateralBlocks(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuFunddate(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCollatInsured(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuFunddateCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuCollatRepay(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuArrear(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuContractTermsChanges(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuArrearCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuDueArrear(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuDuearrear(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuFundDate(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuDuearrearCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuGuaranteeRepay(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPastduearrear(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuGuarantor(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPastduearrearCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuIndepGuarantor(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPaymt(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuLegalRecord(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuPaymtCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuMonthAverPaymt(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuMonthaverpaymt(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuObligAccount(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuMonthaverpaymtCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuObligsRcBankrupt(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSourcenonmonetoblig(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuObligsRcLiquid(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSourcenonmonetobligCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuObligTermination(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSubjectnonmonetoblig(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuOverallval(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuSubjectnonmonetobligCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuPastDueArrear(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCollateral(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuPaymtCondition(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuCollateralCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuPaymt(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuGuarantor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuServiceCo(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuGuarantorCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuSourceNonMonetOblig(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuIndepguarantor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuSubjectNonMonetOblig(Set<Integer> fids);
-    Cursor<LinkedHashMap<String, Object>> findAllByAccSerialNumAndFidFromRuIndepguarantorCursor(String columns, String accSerialNum, String fid);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidsFromRuSubmitHold(Set<Integer> fids);
-    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);
-
-    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);
-
-    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);
-
-    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);
-
-    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);
-
-    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);
 }

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

@@ -3,10 +3,8 @@ package ru.nbch.indicsearchservice.service;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
 import org.apache.commons.lang3.mutable.MutableLong;
@@ -21,8 +19,7 @@ import ru.nbch.indicsearchservice.dto.response.AddSearchJobResponseDto;
 import ru.nbch.indicsearchservice.dto.response.JobStatusResponseDto;
 import ru.nbch.indicsearchservice.exporter.ExcelExporter;
 import ru.nbch.indicsearchservice.exporter.JsonExporter;
-import ru.nbch.indicsearchservice.loader.TableLoader;
+import ru.nbch.indicsearchservice.loader.FirstLevelTableLoader;
-import ru.nbch.indicsearchservice.util.IndicSearchUtils;
 
 @Service
 public class IndicSearchService {
@@ -30,20 +27,17 @@ public class IndicSearchService {
 
     private static final boolean IS_EXPORT_AS_EXCEL = false;
 
-    private final List<TableLoader> tableLoaders;
+    private final List<FirstLevelTableLoader> tableLoaders;
     private final List<FileAggregator> fileAggregators;
-    private final IndicSearchUtils indicSearchUtils;
     private final ExcelExporter excelExporter;
     private final JsonExporter jsonExporter;
 
-    public IndicSearchService(List<TableLoader> tableLoaders,
+    public IndicSearchService(List<FirstLevelTableLoader> tableLoaders,
                               List<FileAggregator> fileAggregators,
-                              IndicSearchUtils indicSearchUtils,
                               ExcelExporter excelExporter,
                               JsonExporter jsonExporter) {
         this.tableLoaders = tableLoaders;
         this.fileAggregators = fileAggregators;
-        this.indicSearchUtils = indicSearchUtils;
         this.excelExporter = excelExporter;
         this.jsonExporter = jsonExporter;
     }
@@ -57,26 +51,15 @@ public class IndicSearchService {
         log.info("First step started. Getting data from database and filling csv files");
         sw.start();
 
-        List<TableLoader> suitableTableLoaders = new ArrayList<>();
+        Map<String, Path> tableFileMap = new ConcurrentHashMap<>();
-        for (TableLoader tableLoader : tableLoaders) {
+        tableLoaders.parallelStream().forEach(tl -> tl.searchBy(
-            if (tableLoader.isSuitableForDataTypeAndSearchParameter(request.getDataType(), request.getSearchParameter())) {
+            taskId,
-                suitableTableLoaders.add(tableLoader);
-            }
-        }
-
-        Set<Integer> foundFids = indicSearchUtils.getFidsBasedOnDataTypeAndSearchParameter(
             request.getDataType(),
             request.getSearchParameter(),
-            request.getSearchValue()
+            request.getSearchValue(),
-        );
+            request.getMemberCode().substring(0, 6),
-
+            tableFileMap
-        Map<String, Path> tableFileMap = new ConcurrentHashMap<>();
+        ));
-        suitableTableLoaders.parallelStream().forEach(tl -> {
-            String tableName = tl.getTableName();
-            Path tableFile = tl.searchByFid(foundFids, taskId);
-
-            tableFileMap.put(tableName, tableFile);
-        });
 
         sw.stop();
         log.info(sw.prettyPrint());
@@ -86,13 +69,17 @@ public class IndicSearchService {
         log.info("Second step started. Aggregating table files into one.");
         sw.start();
 
-        FileAggregator fileAggregator = fileAggregators.stream()
-            .filter(fa -> fa.isSuitableForDataTypeAndSearchParameter(request.getDataType(), request.getSearchParameter()))
-            .findFirst()
-            .orElseThrow(() -> new RuntimeException("There is no suitable file aggregator for data type " + request.getDataType() + " and search parameter " + request.getSearchParameter()));
-
         MutableLong rowCounter = new MutableLong();
-        Path aggregatedFile = fileAggregator.aggregateFiles(tableFileMap, request.getMemberCode().substring(0, 6), rowCounter, taskId);
+        Path aggregatedFile = fileAggregators.stream().map(fa -> fa.aggregateFiles(
+                taskId,
+                request.getDataType(),
+                request.getSearchParameter(),
+                request.getSearchValue(),
+                request.getMemberCode().substring(0, 6),
+                tableFileMap,
+                rowCounter))
+            .findFirst()
+            .orElse(null);
 
         sw.stop();
         log.info(sw.prettyPrint());

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

@@ -5,17 +5,13 @@ import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.StandardOpenOption;
-import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.UUID;
-import java.util.function.Function;
 import org.apache.ibatis.cursor.Cursor;
 import org.springframework.stereotype.Component;
 import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
-import ru.nbch.indicsearchservice.model.enums.DataType;
-import ru.nbch.indicsearchservice.model.enums.SearchParameter;
 
 @Component
 public class IndicSearchUtils {
@@ -25,15 +21,20 @@ public class IndicSearchUtils {
         this.settings = settings;
     }
 
-    public Path writeRowsToFile(String tableName,
+    public Path writeRowsToFile(UUID taskId,
-                                Set<Integer> fids,
+                                String tableName,
-                                Function<Set<Integer>, Cursor<LinkedHashMap<String, Object>>> mapperFunc,
+                                Cursor<LinkedHashMap<String, Object>> databaseCursor) {
-                                UUID taskId) {
+        return writeRowsToFile(taskId, tableName, databaseCursor, null);
+    }
+
+    public Path writeRowsToFile(UUID taskId,
+                                String tableName,
+                                Cursor<LinkedHashMap<String, Object>> databaseCursor,
+                                Set<Integer> foundFids) {
         Path resultFile = settings.getStorageDirectory().toPath().resolve(tableName + "_" + taskId + ".csv");
 
-        try (BufferedWriter writer = Files.newBufferedWriter(resultFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND);
+        try (BufferedWriter writer = Files.newBufferedWriter(resultFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
-             Cursor<LinkedHashMap<String, Object>> cursor = mapperFunc.apply(fids)) {
+            for (LinkedHashMap<String, Object> row : databaseCursor) {
-            for (LinkedHashMap<String, Object> row : cursor) {
                 StringBuilder sb = new StringBuilder();
                 sb.append(tableName).append("%%%");
 
@@ -44,6 +45,10 @@ public class IndicSearchUtils {
                     sb.append(columnName.toUpperCase()).append("%%%");
 
                     if (columnValue != null) {
+                        if (foundFids != null && columnName.equals("FID")) {
+                            foundFids.add(Integer.parseInt(columnValue.toString()));
+                        }
+
                         sb.append(columnValue).append("%%%");
                     } else {
                         sb.append("%%%");
@@ -60,24 +65,4 @@ public class IndicSearchUtils {
 
         return resultFile;
     }
-
-    public Set<Integer> getFidsBasedOnDataTypeAndSearchParameter(DataType dataType, SearchParameter searchParameter, String searchValue) {
-        Set<Integer> fids = new HashSet<>();
-
-        if (dataType == null || searchParameter == null) {
-            return fids;
-        }
-
-        if (dataType == DataType.GUTDF || dataType == DataType.RUTDF) {
-            if (searchParameter == SearchParameter.FID) {
-                return Set.of(Integer.parseInt(searchValue));
-            }
-        } else if (dataType == DataType.TUTDF) {
-            if (searchParameter == SearchParameter.FID) {
-                return Set.of(Integer.parseInt(searchValue));
-            }
-        }
-
-        return fids;
-    }
 }