FWD » Core Development » Database

import java.io.BufferedReader;

import java.io.FileNotFoundException;

import java.io.FileReader;

import java.io.IOException;

import java.io.PrintWriter;

import java.io.UnsupportedEncodingException;

import java.util.Collections;

import java.util.HashMap;

import java.util.Map;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class QueryAnalyzer

{

   private static Map<String, Integer> queries = new HashMap<>(); 

   private static String slowestQuery = null;

   private static double slowestQueryTime = 0;

   private static String mostUsedQuery = null;

   private static int mostUsedQueryCount = 0;

   public static void main(String[] args)

   {

      try (BufferedReader br = new BufferedReader(new FileReader(args[0]))) 

      {

         Pattern queryTypePattern = Pattern.compile("Query type: (.*?);");

         Pattern timePattern = Pattern.compile("Processing time until now: (.*?) ms;");

         Pattern mostUsedPattern = Pattern.compile("Use count: (.*?);");

         for (String line; (line = br.readLine()) != null; ) 

         { 

            // Counting each type of query

            Matcher queryTypeMatch = queryTypePattern.matcher(line);

            if (queryTypeMatch.find())

            {

               String queryType = queryTypeMatch.group(1);

               Integer occurences = queries.get(queryType);

               if (occurences != null)

               {

                  queries.put(queryType, occurences + 1);

               }

               else

               {

                  queries.put(queryType, 1);

               }

            }

            // Determining the slowest query

            Matcher timeMatch = timePattern.matcher(line);

            if (timeMatch.find())

            {

               double time = Double.parseDouble(timeMatch.group(1));

               if (time > slowestQueryTime)

               {

                  slowestQueryTime = time;

                  slowestQuery = line;

               }

            }

            // Determining the most used query

            Matcher mostUsedMatch = mostUsedPattern.matcher(line);

            if (mostUsedMatch.find())

            {

               int count = Integer.parseInt(mostUsedMatch.group(1));

               if (count > mostUsedQueryCount)

               {

                  mostUsedQueryCount = count;

                  mostUsedQuery = line;

               }

            }

         }

      }

      catch (FileNotFoundException e)

      {

         // TODO Auto-generated catch block

         e.printStackTrace();

      }

         catch (IOException e)

      {

         // TODO Auto-generated catch block

         e.printStackTrace();

      }

      StringBuilder sb = new StringBuilder();

      sb.append("Number of each query: \n");

      queries.entrySet().stream().sorted(Collections.reverseOrder(Map.Entry.comparingByValue())).forEach((x) -> {

         sb.append(x + "\n");

      });

      sb.append("\nSlowest query: \n")

        .append(slowestQuery)

        .append("\n\nMost used query: \n")

        .append(mostUsedQuery);

      PrintWriter writer;

      try

      {

         String fileName = args[0].replace(".log", "-analyzed.txt");

         writer = new PrintWriter(fileName);

         writer.println(sb.toString());

         writer.close();

      }

      catch (FileNotFoundException e)

      {

         // TODO Auto-generated catch block

         e.printStackTrace();

      }

   }

}