v3 version added

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

@@ -0,0 +1,21 @@
+package ru.nbch.indicsearchservice.aggregator;
+
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import org.apache.commons.lang3.mutable.MutableLong;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+
+public interface FileAggregator {
+    List<DataType> getSuitableDataTypes();
+    List<SearchParameter> getSuitableSearchParameters();
+    List<String> getRequiredTables();
+
+    default boolean isSuitableForDataTypeAndSearchParameter(DataType dataType, SearchParameter searchParameter) {
+        return getSuitableDataTypes().contains(dataType) && getSuitableSearchParameters().contains(searchParameter);
+    }
+
+    Path aggregateFiles(Map<String, Path> tableFileMap, String memberCode, MutableLong rowCounter, UUID taskId);
+}

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

@@ -0,0 +1,217 @@
+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.Arrays;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import org.apache.commons.lang3.mutable.MutableLong;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.util.MovableBufferedReader;
+
+@Component
+public class FileAggregatorCommon {
+    private static final List<String> RU_UID_CHILD_TABLES = List.of(
+        "RU_TRADE",
+        "RU_ACCOUNT_AMT",
+        "RU_COBORROWER",
+        "RU_PAYMT_CONDITION",
+        "RU_OVERALLVAL",
+        "RU_AMENDMENT",
+        "RU_FUNDDATE",
+        "RU_ARREAR",
+        "RU_DUEARREAR",
+        "RU_PASTDUEARREAR",
+        "RU_PAYMT",
+        "RU_MONTHAVERPAYMT",
+        "RU_SOURCENONMONETOBLIG",
+        "RU_SUBJECTNONMONETOBLIG",
+        "RU_COLLATERAL",
+        "RU_GUARANTOR",
+        "RU_INDEPGUARANTOR",
+        "RU_COLLATINSURED",
+        "RU_COLLATREPAY",
+        "RU_GUARANTEEREPAY",
+        "RU_OBLIGTERMINATION",
+        "RU_SUBMITHOLD",
+        "RU_ACQUIRERLEGAL",
+        "RU_ACQUIRERINDIVID",
+        "RU_SERVICECO",
+        "RU_OBLIGACCOUNT",
+        "RU_LEGALRECORD",
+        "RU_OBLIGSRCBANKRUPT",
+        "RU_OBLIGSRCLIQUID",
+        "RU_AMOUNT_INFO",
+        "RU_CONTRACT_TERMS_CHANGES",
+        "RU_ALL_ARREARS"
+    );
+
+    void aggregateRuUidFiles(Path aggregatedFile, Map<String, Path> tableFileMap, String memberCode, MutableLong rowCounter) {
+        try (BufferedReader ruUidFileReader = Files.newBufferedReader(tableFileMap.get("RU_UID"));
+             BufferedWriter writer = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
+            Map<String, MovableBufferedReader> childTablesReadersMap = new LinkedHashMap<>();
+            for (String tableName : RU_UID_CHILD_TABLES) {
+                if (!tableFileMap.containsKey(tableName)) {
+                    continue;
+                }
+
+                MovableBufferedReader childTablesReader = new MovableBufferedReader(Files.newBufferedReader(tableFileMap.get(tableName)));
+                if (childTablesReader.getCurrentLine() != null) {
+                    childTablesReadersMap.put(tableName, childTablesReader);
+                }
+            }
+
+            String ruUidLine;
+            while ((ruUidLine = ruUidFileReader.readLine()) != null) {
+                List<String> lineList = Arrays.asList(ruUidLine.split(";"));
+                int memberCodeIndex = lineList.indexOf("MEMBER_CODE");
+                if (memberCodeIndex != -1) {
+                    if (!lineList.get(memberCodeIndex + 1).startsWith(memberCode)) {
+                        continue;
+                    }
+                }
+
+                writer.write(ruUidLine);
+                writer.newLine();
+                rowCounter.increment();
+
+                Long ruUidSerialNum = Long.parseLong(ruUidLine.split(";")[2]);
+
+                for (Map.Entry<String, MovableBufferedReader> entry : childTablesReadersMap.entrySet()) {
+                    String childTableName = entry.getKey();
+                    MovableBufferedReader childReader = entry.getValue();
+
+                    String childLine = childReader.getCurrentLine();
+                    if (childLine == null) {
+                        continue;
+                    }
+
+                    Long childAccSerialNum = Long.parseLong(childLine.split(";")[3]);
+
+                    if (ruUidSerialNum > childAccSerialNum) {
+                        while ((childLine = childReader.nextLine()) != null) {
+                            childAccSerialNum = Long.parseLong(childLine.split(";")[3]);
+
+                            if (childAccSerialNum.equals(ruUidSerialNum)) {
+                                writer.write(childLine);
+                                writer.newLine();
+                                rowCounter.increment();
+
+                                if (childTableName.equals("RU_COLLATERAL")) {
+                                    aggregateBlocksTableFile(childTableName, aggregatedFile, tableFileMap, memberCode, rowCounter);
+                                }
+                            }
+
+                            if (childAccSerialNum > ruUidSerialNum) {
+                                break;
+                            }
+                        }
+                    } else if (ruUidSerialNum.equals(childAccSerialNum)) {
+                        writer.write(childLine);
+                        writer.newLine();
+                        rowCounter.increment();
+
+                        if (childTableName.equals("RU_COLLATERAL")) {
+                            aggregateBlocksTableFile(childTableName, aggregatedFile, tableFileMap, memberCode, rowCounter);
+                        }
+
+                        while ((childLine = childReader.nextLine()) != null) {
+                            childAccSerialNum = Long.parseLong(childLine.split(";")[3]);
+
+                            if (childAccSerialNum.equals(ruUidSerialNum)) {
+                                writer.write(childLine);
+                                writer.newLine();
+                                rowCounter.increment();
+
+                                if (childTableName.equals("RU_COLLATERAL")) {
+                                    aggregateBlocksTableFile(childTableName, aggregatedFile, tableFileMap, memberCode, rowCounter);
+                                }
+                            }
+
+                            if (childAccSerialNum > ruUidSerialNum) {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+
+            for (MovableBufferedReader br : childTablesReadersMap.values()) {
+                br.getReader().close();
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    void aggregateBlocksTableFile(String parentTableName, Path aggregatedFile, Map<String, Path> tableFileMap, String memberCode, MutableLong rowCounter) {
+        try (BufferedReader parentFileReader = Files.newBufferedReader(tableFileMap.get(parentTableName));
+             MovableBufferedReader blocksFileReader = new MovableBufferedReader(Files.newBufferedReader(tableFileMap.get(parentTableName + "_BLOCKS")));
+             BufferedWriter writer = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
+            String parentLine;
+            while ((parentLine = parentFileReader.readLine()) != null) {
+                List<String> lineList = Arrays.asList(parentLine.split(";"));
+                int memberCodeIndex = lineList.indexOf("MEMBER_CODE");
+                if (memberCodeIndex != -1) {
+                    if (!lineList.get(memberCodeIndex + 1).startsWith(memberCode)) {
+                        continue;
+                    }
+                }
+
+                writer.write(parentLine);
+                writer.newLine();
+                rowCounter.increment();
+
+                Long parentSerialNum = Long.parseLong(parentLine.split(";")[2]);
+
+                String blocksLine = blocksFileReader.getCurrentLine();
+                if (blocksLine == null) {
+                    continue;
+                }
+
+                Long blocksParentSerialNum = Long.parseLong(blocksLine.split(";")[4]);
+
+                if (parentSerialNum > blocksParentSerialNum) {
+                    while ((blocksLine = blocksFileReader.nextLine()) != null) {
+                        blocksParentSerialNum = Long.parseLong(blocksLine.split(";")[4]);
+
+                        if (blocksParentSerialNum.equals(parentSerialNum)) {
+                            writer.write(blocksLine);
+                            writer.newLine();
+                            rowCounter.increment();
+                        }
+
+                        if (blocksParentSerialNum > parentSerialNum) {
+                            break;
+                        }
+                    }
+                } else if (parentSerialNum.equals(blocksParentSerialNum)) {
+                    writer.write(blocksLine);
+                    writer.newLine();
+                    rowCounter.increment();
+
+                    while ((blocksLine = blocksFileReader.nextLine()) != null) {
+                        blocksParentSerialNum = Long.parseLong(blocksLine.split(";")[4]);
+
+                        if (blocksParentSerialNum.equals(parentSerialNum)) {
+                            writer.write(blocksLine);
+                            writer.newLine();
+                            rowCounter.increment();
+                        }
+
+                        if (blocksParentSerialNum > parentSerialNum) {
+                            break;
+                        }
+                    }
+                }
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

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

@@ -0,0 +1,97 @@
+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.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import org.apache.commons.lang3.mutable.MutableLong;
+import org.springframework.stereotype.Component;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
+import ru.nbch.indicsearchservice.model.enums.DataType;
+import ru.nbch.indicsearchservice.model.enums.SearchParameter;
+
+@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");
+
+        for (String tableName : getRequiredTables()) {
+            if (tableName.equals("RU_UID")) {
+                fileAggregatorCommon.aggregateRuUidFiles(aggregatedFile, tableFileMap, memberCode, rowCounter);
+            } else if (tableName.equals("RU_BANKRUPTCY")) {
+                fileAggregatorCommon.aggregateBlocksTableFile(tableName, aggregatedFile, tableFileMap, memberCode, rowCounter);
+            } else {
+                try (BufferedReader reader = Files.newBufferedReader(tableFileMap.get(tableName));
+                     BufferedWriter writer = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
+                    String line;
+
+                    while ((line = reader.readLine()) != null) {
+                        List<String> lineList = Arrays.asList(line.split(";"));
+                        int memberCodeIndex = lineList.indexOf("MEMBER_CODE");
+                        if (memberCodeIndex != -1) {
+                            if (!lineList.get(memberCodeIndex + 1).startsWith(memberCode)) {
+                                continue;
+                            }
+                        }
+
+                        writer.write(line);
+                        writer.newLine();
+                        rowCounter.increment();
+                    }
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+
+        try (BufferedWriter writer = Files.newBufferedWriter(aggregatedFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND)) {
+            writer.write("EOF");
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+
+        return aggregatedFile;
+    }
+}

src/main/java/ru/nbch/indicsearchservice/filter/secondlevel/RuUidSecondLevelTableFilter.java

@@ -11,19 +11,19 @@ import ru.nbch.indicsearchservice.model.TableData;
 @Component
 public class RuUidSecondLevelTableFilter implements SecondLevelTableFilter {
     private static final Set<String> SUPPORTED_TABLE_NAMES = Set.of(
-        "RU_TRADE",
         "RU_ACCOUNT_AMT",
-        "RU_COBORROWER",
-        "RU_PAYMT_CONDITION",
-        "RU_OVERALLVAL",
         "RU_AMENDMENT",
-        "RU_FUNDDATE",
         "RU_ARREAR",
+        "RU_COBORROWER",
         "RU_DUEARREAR",
+        "RU_FUNDDATE",
+        "RU_MONTHAVERPAYMT",
+        "RU_OVERALLVAL",
         "RU_PASTDUEARREAR",
         "RU_PAYMT",
-        "RU_MONTHAVERPAYMT",
+        "RU_PAYMT_CONDITION",
-        "RU_SOURCENONMONETOBLIG"
+        "RU_SOURCENONMONETOBLIG",
+        "RU_TRADE"
     );
 
     @Override

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuAccountAmtTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAccountAmt(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAccountAmt(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuAcquirerIndividTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerIndivid(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerIndivid(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuAcquirerLegalTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerLegal(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAcquirerLegal(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuAllArrearsTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAllArrears(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAllArrears(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuAmendmentTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAmendment(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAmendment(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuAmountInfoTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuAmountInfo(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuAmountInfo(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuApplicationTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuApplication(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuApplication(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuArrearTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuArrear(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuArrear(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuBankruptcyBlocksTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcyBlocks(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcyBlocks(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuBankruptcyTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcy(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuBankruptcy(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuCapabilityTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCapability(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCapability(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuCoborrowerTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCoborrower(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCoborrower(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuCollatInsuredTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollatInsured(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollatInsured(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuCollatRepayTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollatRepay(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollatRepay(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuCollateralBlocksTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollateralBlocks(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollateralBlocks(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuCollateralTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuCollateral(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuCollateral(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuContractTermsChangesTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuContractTermsChanges(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuContractTermsChanges(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuDebtBurdenInfoTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuDebtBurdenInfo(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuDebtBurdenInfo(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuDueArrearTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuDueArrear(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuDueArrear(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuFundDateTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuFundDate(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuFundDate(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuGuaranteeRepayTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuGuaranteeRepay(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuGuaranteeRepay(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuGuarantorTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuGuarantor(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuGuarantor(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuIndepGuarantorTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuIndepGuarantor(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuIndepGuarantor(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuLegalRecordTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuLegalRecord(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuLegalRecord(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuMonthAverPaymtTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuMonthAverPaymt(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuMonthAverPaymt(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuObligAccountTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligAccount(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligAccount(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuObligPartTakeTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligPartTake(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligPartTake(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuObligTerminationTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligTermination(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligTermination(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuObligsRcBankruptTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcBankrupt(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcBankrupt(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuObligsRcLiquidTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcLiquid(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuObligsRcLiquid(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuOtherLegalTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuOtherLegal(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuOtherLegal(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -20,6 +20,7 @@ public class RuOverallvalTableLoader implements TableLoader {
                                    IndicSearchUtils indicSearchUtils) {
         this.mapperHolder = mapperHolder;
         this.indicSearchUtils = indicSearchUtils;
+
     }
 
     @Override
@@ -38,15 +39,8 @@ public class RuOverallvalTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuOverallval(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuOverallval(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuPastDueArrearTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuPastDueArrear(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuPastDueArrear(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuPaymtConditionTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuPaymtCondition(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuPaymtCondition(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuPaymtTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuPaymt(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuPaymt(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuServiceCoTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuServiceCo(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuServiceCo(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuSettledTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSettled(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSettled(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuSourceNonMonetObligTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSourceNonMonetOblig(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSourceNonMonetOblig(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuSubjectNonMonetObligTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSubjectNonMonetOblig(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSubjectNonMonetOblig(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuSubmitHoldTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuSubmitHold(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuSubmitHold(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuTradeTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuTrade(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuTrade(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,11 +1,11 @@
 package ru.nbch.indicsearchservice.loader;
 
-import java.util.ArrayList;
+import java.nio.file.Path;
-import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Set;
+import java.util.UUID;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+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;
@@ -38,15 +38,8 @@ public class RuUidTableLoader implements TableLoader {
     }
 
     @Override
-    public List<TableData> searchByFid(Set<Integer> fids) {
+    @Transactional(readOnly = true)
-        List<LinkedHashMap<String, Object>> foundTableRows = mapperHolder.getIndicMapper().findAllByFidFromRuUid(fids);
+    public Path searchByFid(Set<Integer> fids, UUID taskId) {
-
+        return indicSearchUtils.writeRowsToFile(getTableName(), fids, fidSet -> mapperHolder.getIndicMapper().findAllByFidFromRuUid(fidSet), taskId);
-        List<TableData> resultTableData = new ArrayList<>();
-        for (LinkedHashMap<String, Object> row : foundTableRows) {
-            TableData parsedTableData = indicSearchUtils.mapToTableData(getTableName(), row);
-            resultTableData.add(parsedTableData);
-        }
-
-        return resultTableData;
     }
 }

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

@@ -1,8 +1,9 @@
 package ru.nbch.indicsearchservice.loader;
 
+import java.nio.file.Path;
 import java.util.List;
 import java.util.Set;
-import ru.nbch.indicsearchservice.model.TableData;
+import java.util.UUID;
 import ru.nbch.indicsearchservice.model.enums.DataType;
 import ru.nbch.indicsearchservice.model.enums.SearchParameter;
 
@@ -15,5 +16,5 @@ public interface TableLoader {
         return getSuitableDataTypes().contains(dataType) && getSuitableSearchParameters().contains(searchParameter);
     }
 
-    List<TableData> searchByFid(Set<Integer> fids);
+    Path searchByFid(Set<Integer> fids, UUID taskId);
 }

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

@@ -11,48 +11,48 @@ import ru.nbch.indicsearchservice.repository.MyBatisRepository;
 public interface IndicMapper extends MyBatisRepository {
     List<LinkedHashMap<String, String>> getTableColumnsByTableNames(List<String> tables);
 
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuUid(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuUid(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuTrade(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuTrade(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuApplication(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuApplication(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuAccountAmt(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAccountAmt(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuAcquirerIndivid(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAcquirerIndivid(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuAcquirerLegal(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAcquirerLegal(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuAllArrears(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAllArrears(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuAmendment(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAmendment(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuAmountInfo(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuAmountInfo(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuArrear(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuArrear(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuBankruptcy(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuBankruptcy(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuBankruptcyBlocks(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuBankruptcyBlocks(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuCapability(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCapability(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuCoborrower(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCoborrower(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuCollateral(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCollateral(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuCollateralBlocks(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCollateralBlocks(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuCollatInsured(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCollatInsured(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuCollatRepay(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuCollatRepay(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuContractTermsChanges(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuContractTermsChanges(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuDebtBurdenInfo(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuDebtBurdenInfo(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuDueArrear(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuDueArrear(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuFundDate(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuFundDate(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuGuaranteeRepay(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuGuaranteeRepay(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuGuarantor(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuGuarantor(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuIndepGuarantor(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuIndepGuarantor(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuLegalRecord(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuLegalRecord(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuMonthAverPaymt(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuMonthAverPaymt(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuObligAccount(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuObligAccount(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuObligPartTake(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuObligPartTake(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuObligsRcBankrupt(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuObligsRcBankrupt(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuObligsRcLiquid(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuObligsRcLiquid(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuObligTermination(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuObligTermination(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuOtherLegal(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuOtherLegal(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuOverallval(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuOverallval(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuPastDueArrear(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuPastDueArrear(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuPaymtCondition(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuPaymtCondition(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuPaymt(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuPaymt(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuServiceCo(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuServiceCo(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuSettled(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuSettled(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuSourceNonMonetOblig(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuSourceNonMonetOblig(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuSubjectNonMonetOblig(Set<Integer> fids);
+    Cursor<LinkedHashMap<String, Object>> findAllByFidFromRuSubjectNonMonetOblig(Set<Integer> fids);
-    List<LinkedHashMap<String, Object>> findAllByFidFromRuSubmitHold(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>> findAllByAcctNumAndMemberCodeFromRuUidCursor(String columns, String acctNum, String memberCode);

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

@@ -7,20 +7,19 @@ 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;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 import org.springframework.util.StopWatch;
+import ru.nbch.indicsearchservice.aggregator.FileAggregator;
 import ru.nbch.indicsearchservice.dto.request.AddSearchJobRequestDto;
 import ru.nbch.indicsearchservice.dto.response.AddSearchJobResponseDto;
 import ru.nbch.indicsearchservice.dto.response.JobStatusResponseDto;
-import ru.nbch.indicsearchservice.filter.firstlevel.DefaultFirstLevelTableFilter;
-import ru.nbch.indicsearchservice.filter.secondlevel.SecondLevelTableFilter;
-import ru.nbch.indicsearchservice.filter.thirdlevel.ThirdLevelTableFilter;
 import ru.nbch.indicsearchservice.loader.TableLoader;
-import ru.nbch.indicsearchservice.model.TableData;
 import ru.nbch.indicsearchservice.util.ExcelWriter;
 import ru.nbch.indicsearchservice.util.IndicSearchUtils;
 import tools.jackson.databind.json.JsonMapper;
@@ -32,32 +31,31 @@ public class IndicSearchService {
     private static final boolean IS_EXPORT_AS_EXCEL = true;
 
     private final List<TableLoader> tableLoaders;
-    private final DefaultFirstLevelTableFilter firstLevelTableFilter;
+    private final List<FileAggregator> fileAggregators;
-    private final List<SecondLevelTableFilter> secondLevelTableFilters;
-    private final List<ThirdLevelTableFilter> thirdLevelTableFilters;
     private final IndicSearchUtils indicSearchUtils;
     private final ExcelWriter excelWriter;
 
     private final JsonMapper jsonMapper;
 
     public IndicSearchService(List<TableLoader> tableLoaders,
-                              DefaultFirstLevelTableFilter firstLevelTableFilter,
+                              List<FileAggregator> fileAggregators,
-                              List<SecondLevelTableFilter> secondLevelTableFilters,
-                              List<ThirdLevelTableFilter> thirdLevelTableFilters,
                               IndicSearchUtils indicSearchUtils,
                               ExcelWriter excelWriter,
                               JsonMapper jsonMapper) {
         this.tableLoaders = tableLoaders;
-        this.firstLevelTableFilter = firstLevelTableFilter;
+        this.fileAggregators = fileAggregators;
-        this.secondLevelTableFilters = secondLevelTableFilters;
-        this.thirdLevelTableFilters = thirdLevelTableFilters;
         this.indicSearchUtils = indicSearchUtils;
         this.excelWriter = excelWriter;
         this.jsonMapper = jsonMapper;
     }
 
     public AddSearchJobResponseDto addSearchJob(AddSearchJobRequestDto request) {
+        UUID taskId = UUID.randomUUID();
+
         StopWatch sw = new StopWatch();
+
+        // Первый этап. Получение данных из БД и заполнение файлов
+        log.info("First step started. Getting data from database and filling csv files");
         sw.start();
 
         List<TableLoader> suitableTableLoaders = new ArrayList<>();
@@ -73,28 +71,64 @@ public class IndicSearchService {
             request.getSearchValue()
         );
 
-        Map<String, List<TableData>> tableDataMapByFid = new ConcurrentHashMap<>();
+        Map<String, Path> tableFileMap = new ConcurrentHashMap<>();
-        suitableTableLoaders.parallelStream().forEach(tl -> tableDataMapByFid.put(tl.getTableName(), tl.searchByFid(foundFids)));
+        suitableTableLoaders.parallelStream().forEach(tl -> {
-//        for (TableLoader tableLoader : suitableTableLoaders) {
+            String tableName = tl.getTableName();
-//            tableDataMapByFid.put(tableLoader.getTableName(), tableLoader.searchByFid(foundFids));
+            Path tableFile = tl.searchByFid(foundFids, taskId);
-//        }
 
-        List<TableData> result = firstLevelTableFilter.applyFilter(tableDataMapByFid, request.getMemberCode());
+            tableFileMap.put(tableName, tableFile);
-        secondLevelTableFilters.forEach(f -> f.applyFilter(result, tableDataMapByFid));
+        });
-        thirdLevelTableFilters.forEach(f -> f.applyFilter(result, tableDataMapByFid));
+
+        sw.stop();
+        log.info(sw.prettyPrint());
+        sw = new StopWatch();
+
+        // Второй этап. Объединение файлов в один
+        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);
+
+        sw.stop();
+        log.info(sw.prettyPrint());
+        sw = new StopWatch();
+
+        for (Path tableFilePath : tableFileMap.values()) {
+            try {
+                Files.deleteIfExists(tableFilePath);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        // Третий этап. Экспорт агрегированного файла в JSON или XLSX
+        log.info("Third step started. Exporting aggregated file into JSON/XLSX.");
+        sw.start();
+
+        if (!IS_EXPORT_AS_EXCEL) {
+//            try {
+//                Files.write(Path.of("1.json"), jsonMapper.writeValueAsBytes(result));
+//            } catch (IOException e) {
+//                throw new RuntimeException(e);
+//            }
+        } else {
+            excelWriter.writeExcelFile(aggregatedFile, taskId);
+        }
 
         sw.stop();
         log.info(sw.prettyPrint());
 
-        if (!IS_EXPORT_AS_EXCEL) {
+//        try {
-            try {
+//            Files.deleteIfExists(aggregatedFile);
-                Files.write(Path.of("1.json"), jsonMapper.writeValueAsBytes(result));
+//        } catch (IOException e) {
-            } catch (IOException e) {
+//            throw new RuntimeException(e);
-                throw new RuntimeException(e);
+//        }
-            }
-        } else {
-            excelWriter.writeExcelFile(result);
-        }
 
         return null;
     }

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

@@ -1,15 +1,21 @@
 package ru.nbch.indicsearchservice.util;
 
 import jakarta.annotation.Nullable;
+import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.stream.Collectors;
+import java.util.Set;
-import org.apache.commons.lang3.mutable.MutableInt;
+import java.util.UUID;
+import org.apache.commons.lang3.mutable.MutableLong;
 import org.apache.poi.ss.usermodel.BorderStyle;
 import org.apache.poi.ss.usermodel.Cell;
 import org.apache.poi.ss.usermodel.CellStyle;
@@ -23,39 +29,62 @@ import org.apache.poi.xssf.usermodel.XSSFFont;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.stereotype.Component;
-import ru.nbch.indicsearchservice.model.TableData;
+import ru.nbch.indicsearchservice.config.settings.ApplicationSettings;
 
 @Component
 public class ExcelWriter {
     private static final Logger log = LoggerFactory.getLogger(ExcelWriter.class);
+    private static final Long EXCEL_SHEET_MAX_SIZE = 1_048_575L;
 
-    public void writeExcelFile(List<TableData> tableDataList) {
+    private static final Set<String> FIRST_LEVEL_TABLES = Set.of(
-        Map<String, List<TableData>> tableDataGroupedByTables = tableDataList.stream()
+        "RU_UID",
-            .collect(Collectors.groupingBy(TableData::getTableName));
+        "RU_APPLICATION",
+        "RU_OBLIGPARTTAKE",
+        "RU_BANKRUPTCY",
+        "RU_SETTLED",
+        "RU_OTHERLEGAL",
+        "RU_CAPABILITY",
+        "RU_DEBT_BURDEN_INFO"
+    );
 
-        Path excelFile = Path.of("2.xlsx");
+    private final ApplicationSettings settings;
 
-        try (SXSSFWorkbook workbook = new SXSSFWorkbook();
+    public ExcelWriter(ApplicationSettings settings) {
-             OutputStream os = Files.newOutputStream(excelFile)) {
+        this.settings = settings;
+    }
+
+    public void writeExcelFile(Path aggregatedFile, UUID taskId) {
+        Path excelFile = settings.getStorageDirectory().toPath().resolve(taskId.toString() + ".xlsx");
+
+        try (OutputStream os = Files.newOutputStream(excelFile);
+             BufferedReader aggregatedFileReader = Files.newBufferedReader(aggregatedFile);
+             SXSSFWorkbook workbook = new SXSSFWorkbook()) {
             CellStyle headerCellStyle = createHeaderCellStyle(workbook);
             CellStyle cellStyle = createCellStyle(workbook);
 
-            for (Map.Entry<String, List<TableData>> entry : tableDataGroupedByTables.entrySet()) {
+            Iterator<String> iterator = aggregatedFileReader.lines().iterator();
-                String tableName = entry.getKey();
-                List<TableData> tableRows = entry.getValue();
 
-                Sheet tableSheet = createSheet(workbook, tableName.toUpperCase());
+            MutableLong sheetRowCounter = new MutableLong(0L);
-                MutableInt currentRow = new MutableInt(0);
+            MutableLong sheetTableCounter = new MutableLong(1L);
 
-                for (TableData tableRow : tableRows) {
+            boolean isFirst = true;
-                    writeDataSheetIntoSheetRow(
+            String lastTableName = null;
-                        tableRow,
+            List<String> rows = new ArrayList<>();
-                        tableSheet,
+            while (iterator.hasNext()) {
-                        currentRow,
+                String line = iterator.next();
-                        headerCellStyle,
+
-                        cellStyle
+                if (!isFirst && (FIRST_LEVEL_TABLES.contains(line.split(";")[0]) || line.equals("EOF"))) {
-                    );
+                    lastTableName = rows.getFirst().split(";")[0];
+                    writeToExcel(workbook, rows, sheetRowCounter, sheetTableCounter, headerCellStyle, cellStyle);
+                    if (lastTableName != null && !lastTableName.equals(line.split(";")[0])) {
+                        sheetRowCounter.setValue(0L);
+                        sheetTableCounter.setValue(1L);
+                    }
+                    rows.clear();
                 }
+
+                rows.add(line);
+                isFirst = false;
             }
 
             workbook.write(os);
@@ -64,6 +93,61 @@ public class ExcelWriter {
         }
     }
 
+    private void writeToExcel(Workbook workbook,
+                              List<String> rows,
+                              MutableLong sheetRowCounter,
+                              MutableLong sheetTableCounter,
+                              CellStyle headerCellStyle,
+                              CellStyle cellStyle) {
+        if (rows == null || rows.isEmpty()) {
+            return;
+        }
+
+        String parentTableName = rows.getFirst().split(";")[0];
+
+        Sheet tableSheet;
+        if (sheetRowCounter.longValue() + (rows.size() * 2L) >= EXCEL_SHEET_MAX_SIZE) {
+            tableSheet = createSheet(workbook, parentTableName.toUpperCase() + "_" + sheetTableCounter.incrementAndGet());
+            sheetRowCounter.setValue(0L);
+        } else {
+            tableSheet = createSheet(workbook, parentTableName.toUpperCase() + "_" + sheetTableCounter.longValue());
+        }
+
+        for (String row : rows) {
+            List<String> rowList = Arrays.asList(row.split(";", -1));
+            String tableName = rowList.getFirst();
+
+            List<String> rowSublist = rowList.subList(5, rowList.size());
+            Map<String, String> rowValues = new HashMap<>();
+            for (int i = 0; i + 1 <= rowSublist.size(); i = i + 2) {
+                rowValues.put(rowSublist.get(i), rowSublist.get(i + 1));
+            }
+
+            createHeaderRow(
+                tableName,
+                tableSheet,
+                sheetRowCounter,
+                headerCellStyle
+            );
+
+            for (Map.Entry<String, String> entry : rowValues.entrySet()) {
+                String columnName = entry.getKey();
+                String columnValue = entry.getValue();
+
+                writeFieldDataIntoSheetRow(
+                    columnName,
+                    columnName,
+                    columnValue,
+                    tableSheet,
+                    sheetRowCounter,
+                    cellStyle
+                );
+            }
+
+            sheetRowCounter.increment();
+        }
+    }
+
     private CellStyle createHeaderCellStyle(Workbook workbook) {
         CellStyle headerCellStyle = workbook.createCellStyle();
         headerCellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
@@ -94,17 +178,23 @@ public class ExcelWriter {
     }
 
     private Sheet createSheet(Workbook workbook, String sheetName) {
-        Sheet sheet = workbook.createSheet(sheetName);
+        Sheet foundSheet = workbook.getSheet(sheetName);
-        sheet.setColumnWidth(0, 25 * 256);
-        sheet.setColumnWidth(1, 115 * 256);
-        sheet.setColumnWidth(2, 38 * 256);
 
-        return sheet;
+        if (foundSheet == null) {
+            Sheet sheet = workbook.createSheet(sheetName);
+            sheet.setColumnWidth(0, 25 * 256);
+            sheet.setColumnWidth(1, 115 * 256);
+            sheet.setColumnWidth(2, 38 * 256);
+
+            return sheet;
+        }
+
+        return foundSheet;
     }
 
     private void createHeaderRow(String localizedTableName,
                                  Sheet sheet,
-                                 MutableInt currentRow,
+                                 MutableLong currentRow,
                                  CellStyle headerCellStyle) {
         Row headerRow = sheet.createRow(currentRow.intValue());
         headerRow.setHeightInPoints(15);
@@ -117,49 +207,11 @@ public class ExcelWriter {
         currentRow.increment();
     }
 
-    public void writeDataSheetIntoSheetRow(TableData tableData,
-                                           Sheet sheet,
-                                           MutableInt currentRow,
-                                           CellStyle headerCellStyle,
-                                           CellStyle cellStyle) {
-        createHeaderRow(
-            tableData.getTableName(),
-            sheet,
-            currentRow,
-            headerCellStyle
-        );
-
-        for (TableData.FieldData fieldData : tableData.getFieldData()) {
-            writeFieldDataIntoSheetRow(
-                fieldData.columnName(),
-                fieldData.columnName(),
-                fieldData.columnValue(),
-                sheet,
-                currentRow,
-                cellStyle
-            );
-        }
-
-        currentRow.increment();
-
-        if (!tableData.getRelatedTableData().isEmpty()) {
-            for (TableData relatedTableData : tableData.getRelatedTableData()) {
-                writeDataSheetIntoSheetRow(
-                    relatedTableData,
-                    sheet,
-                    currentRow,
-                    headerCellStyle,
-                    cellStyle
-                );
-            }
-        }
-    }
-
     private void writeFieldDataIntoSheetRow(String fieldKey,
                                             String localizedFieldKey,
                                             @Nullable Object fieldValue,
                                             Sheet sheet,
-                                            MutableInt currentRow,
+                                            MutableLong currentRow,
                                             CellStyle cellStyle) {
         Row dataRow = sheet.createRow(currentRow.intValue());
         dataRow.setHeightInPoints(15);

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

@@ -1,21 +1,97 @@
 package ru.nbch.indicsearchservice.util;
 
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
 import java.sql.Date;
 import java.sql.Timestamp;
 import java.time.LocalDate;
 import java.time.format.DateTimeFormatter;
 import java.util.ArrayList;
 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.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.TableData;
 import ru.nbch.indicsearchservice.model.enums.DataType;
 import ru.nbch.indicsearchservice.model.enums.SearchParameter;
 
 @Component
 public class IndicSearchUtils {
+    private final ApplicationSettings settings;
+
+    public IndicSearchUtils(ApplicationSettings settings) {
+        this.settings = settings;
+    }
+
+    public Path writeRowsToFile(String tableName,
+                                Set<Integer> fids,
+                                Function<Set<Integer>, Cursor<LinkedHashMap<String, Object>>> mapperFunc,
+                                UUID taskId) {
+        Path resultFile = settings.getStorageDirectory().toPath().resolve(tableName + "_" + taskId + ".csv");
+
+        try (BufferedWriter writer = Files.newBufferedWriter(resultFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND);
+             Cursor<LinkedHashMap<String, Object>> cursor = mapperFunc.apply(fids)) {
+            for (LinkedHashMap<String, Object> row : cursor) {
+                StringBuilder sb = new StringBuilder();
+                sb.append(tableName).append(";");
+
+                if (row.containsKey("FID") && row.get("FID") != null) {
+                    sb.append(row.get("FID").toString()).append(";");
+                } else {
+                    sb.append(";");
+                }
+
+                if (row.containsKey("SERIAL_NUM") && row.get("SERIAL_NUM") != null) {
+                    sb.append(row.get("SERIAL_NUM").toString()).append(";");
+                } else {
+                    sb.append(";");
+                }
+
+                if (row.containsKey("ACC_SERIAL_NUM") && row.get("ACC_SERIAL_NUM") != null) {
+                    sb.append(row.get("ACC_SERIAL_NUM").toString()).append(";");
+                } else {
+                    sb.append(";");
+                }
+
+                if (row.containsKey("PARENT_SERIAL_NUM") && row.get("PARENT_SERIAL_NUM") != null) {
+                    sb.append(row.get("PARENT_SERIAL_NUM").toString()).append(";");
+                } else {
+                    sb.append(";");
+                }
+
+                for (Map.Entry<String, Object> entry : row.entrySet()) {
+                    String columnName = entry.getKey();
+                    Object columnValue = entry.getValue();
+
+                    sb.append(columnName.toUpperCase()).append(";");
+
+                    if (columnValue != null) {
+                        sb.append(columnValue).append(";");
+                    } else {
+                        sb.append(";");
+                    }
+                }
+
+                sb.deleteCharAt(sb.length() - 1);
+                writer.write(sb.toString());
+                writer.newLine();
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+
+        return resultFile;
+    }
+
     public Set<Integer> getFidsBasedOnDataTypeAndSearchParameter(DataType dataType, SearchParameter searchParameter, String searchValue) {
         Set<Integer> fids = new HashSet<>();
 

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

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

src/main/resources/application.properties

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

src/main/resources/mappers/indic/indic_mapper.xml

@@ -14,423 +14,465 @@
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuUid" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuUid" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_UID
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuTrade" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuTrade" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_TRADE
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, ACC_SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuApplication" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuApplication" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_APPLICATION
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuAccountAmt" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuAccountAmt" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_ACCOUNT_AMT
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, ACC_SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuAcquirerIndivid" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuAcquirerIndivid" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_ACQUIRERINDIVID
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuAcquirerLegal" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuAcquirerLegal" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_ACQUIRERLEGAL
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuAllArrears" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuAllArrears" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_ALL_ARREARS
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuAmendment" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuAmendment" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_AMENDMENT
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, ACC_SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuAmountInfo" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuAmountInfo" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_AMOUNT_INFO
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuArrear" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuArrear" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_ARREAR
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, ACC_SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuBankruptcy" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuBankruptcy" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_BANKRUPTCY
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuBankruptcyBlocks" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuBankruptcyBlocks" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_BANKRUPTCY_BLOCKS
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuCapability" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuCapability" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_CAPABILITY
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuCoborrower" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuCoborrower" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_COBORROWER
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, ACC_SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuCollateral" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuCollateral" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_COLLATERAL
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuCollateralBlocks" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuCollateralBlocks" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_COLLATERAL_BLOCKS
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuCollatInsured" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuCollatInsured" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_COLLATINSURED
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuCollatRepay" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuCollatRepay" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_COLLATREPAY
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuContractTermsChanges" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuContractTermsChanges" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_CONTRACT_TERMS_CHANGES
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuDebtBurdenInfo" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuDebtBurdenInfo" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_DEBT_BURDEN_INFO
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuDueArrear" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuDueArrear" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_DUEARREAR
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, ACC_SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuFundDate" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuFundDate" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_FUNDDATE
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, ACC_SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuGuaranteeRepay" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuGuaranteeRepay" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_GUARANTEEREPAY
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuGuarantor" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuGuarantor" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_GUARANTOR
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuIndepGuarantor" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuIndepGuarantor" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_INDEPGUARANTOR
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuLegalRecord" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuLegalRecord" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_LEGALRECORD
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuMonthAverPaymt" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuMonthAverPaymt" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_MONTHAVERPAYMT
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, ACC_SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuObligAccount" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuObligAccount" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_OBLIGACCOUNT
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuObligPartTake" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuObligPartTake" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_OBLIGPARTTAKE
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuObligsRcBankrupt" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuObligsRcBankrupt" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_OBLIGSRCBANKRUPT
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuObligsRcLiquid" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuObligsRcLiquid" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_OBLIGSRCLIQUID
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuObligTermination" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuObligTermination" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_OBLIGTERMINATION
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuOtherLegal" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuOtherLegal" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_OTHERLEGAL
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuOverallval" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuOverallval" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_OVERALLVAL
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, ACC_SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuPastDueArrear" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuPastDueArrear" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_PASTDUEARREAR
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, ACC_SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuPaymtCondition" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuPaymtCondition" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_PAYMT_CONDITION
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, ACC_SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuPaymt" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuPaymt" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_PAYMT
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, ACC_SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuServiceCo" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuServiceCo" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_SERVICECO
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuSettled" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuSettled" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_SETTLED
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuSourceNonMonetOblig" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuSourceNonMonetOblig" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_SOURCENONMONETOBLIG
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, ACC_SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuSubjectNonMonetOblig" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuSubjectNonMonetOblig" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_SUBJECTNONMONETOBLIG
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>
 
-    <select id="findAllByFidFromRuSubmitHold" resultType="java.util.LinkedHashMap" timeout="60">
+    <select id="findAllByFidFromRuSubmitHold" resultType="java.util.LinkedHashMap" fetchSize="1000" timeout="3600">
         SELECT *
         FROM INDIC.RU_SUBMITHOLD
         WHERE FID IN
         <foreach item="fid" collection="fids" open="(" separator="," close=")">
             #{fid}
         </foreach>
+        ORDER BY FID, SERIAL_NUM
         WITH UR
     </select>