Dev2

private static class QueryInfo {

    private final String query;

    private int stuckCount;

    private int activeCount;

    private final Set<String> threadIds;

    private final Set<Integer> lineNumbers;



    public QueryInfo(String query) {

        this.query = query;

        this.stuckCount = 0;

        this.activeCount = 0;

        this.threadIds = new HashSet<>();

        this.lineNumbers = new HashSet<>();

    }



    public int getStuckCount() {

        return stuckCount;

    }



    public void setStuckCount(int stuckCount) {

        this.stuckCount = stuckCount;

    }



    public int getActiveCount() {

        return activeCount;

    }



    public void incrementStuck() {

        this.stuckCount++;

    }



    public void incrementActive() {

        this.activeCount++;

    }



    public void addThreadId(String threadId) {

        this.threadIds.add(threadId);

    }



    public void addLineNumber(Integer lineNumber) {

        this.lineNumbers.add(lineNumber);

    }



    @Override

    public String toString() {

        return String.format(

                "Query: %s%nStuck Count: %d%nActive Count: %d%nThread IDs: %s%nLine Numbers: %s%n",

                query, stuckCount, activeCount, threadIds, lineNumbers

        );

    }

}



private final Map<String, QueryInfo> queryMap = new HashMap<>();

private final StringBuilder currentQuery = new StringBuilder();

private String currentThread;

private String currentStatus;

private Integer currentLineNum;

private Boolean isCollectingQuery;



private static final Pattern LOG_PATTERN = Pattern.compile(

        "Line (\\d+): DEBUG .*?" +

                "\\[(STUCK|ACTIVE)\\] " +

                "ExecuteThread: '(\\d+)' .*?" +

                "(?:Preparing: )?(SELECT.+?)(?:;\\s*$|(?=Line \\d+: DEBUG))",

        Pattern.DOTALL

);



private static final String LOG_FILE_PATH = "C:/Users/Downloads/client_load.log"; // Corrected path



public SQLAnalyzer() {

    // No need for initializations here

}



private String normalizeQuery(String query) {

    // ... (Your normalization logic - this is fine)

}



public Map<String, QueryInfo> analyzeLogs() throws IOException {

    try (BufferedReader reader = new BufferedReader(new FileReader(LOG_FILE_PATH))) {

        String line;

        while ((line = reader.readLine()) != null) {

            processLine(line);

        }

        if (isCollectingQuery) {

            finalizeQuery();

        }

    }

    return queryMap;

}



private void processLine(String line) {

    // ... (Your processLine logic - this is fine)

}



private void finalizeQuery() {

    String normalizedQuery = normalizeQuery(currentQuery.toString());



    QueryInfo info = queryMap.computeIfAbsent(normalizedQuery, QueryInfo::new);



    if (Objects.equals(currentStatus, "STUCK")) {

        info.incrementStuck();

    } else if (Objects.equals(currentStatus, "ACTIVE")) {

        info.incrementActive();

    }



    info.addThreadId(currentThread);

    info.addLineNumber(currentLineNum);



    isCollectingQuery = false;

    currentQuery.setLength(0);

}



public void printAnalysis() {

    System.out.println("=== SQL Query Analysis ===\n");



    queryMap.entrySet().stream()

            .sorted(Comparator.comparingInt(entry -> entry.getValue().getStuckCount() + entry.getValue().getActiveCount()).reversed())

            .forEach(entry -> {

                System.out.println(entry.getValue().toString());

                System.out.println(String.join("", Collections.nCopies(80, "-")) + "\n");

            });

}



public static void main(String[] args) {

    SQLAnalyzer analyzer = new SQLAnalyzer();

    try {

        analyzer.analyzeLogs();

        analyzer.printAnalysis();

    } catch (IOException e) {

        System.err.println("Error reading log file: " + e.getMessage());

        e.printStackTrace();

    }

}