query_police 0.1.2.beta → 0.1.4.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3ba602c5b4a73be62b2660559a20d3314acbe30215cdb501163d4ced4851112
-  data.tar.gz: defbfd46a5b7702205e0a3acd7c426374eea75ceb477e8e403972ef8519fb9e8
+  metadata.gz: 8be9c9ecaea3622ddb4c569a289fba9ba8f6fde860bb5a987d1176cba557d4bf
+  data.tar.gz: 8bdf19f5812a8bc990835d808f5bbc17c17764ed7cd853f11dfd9ae8d4d32984
 SHA512:
-  metadata.gz: 06dde4464e7020f9bfb187980f77463b96e7b18d25dacfaf6b58f42cfe538d49ad27e49e62a3294b1b8f312e573d8b252a8c7163c83a0f7ee21c59fd95ee2888
-  data.tar.gz: 94950f4b507c314b9cd2f8966516826034028a02d38e089a506067f4466f8273031c94b41c6c998299ca24c5315f061ca5315a79504d921bb7b5f1058d74ae9a
+  metadata.gz: 877344423887126e3b8d19ede4755e3d73c07172376340227119975835ab474b2dad60779afe284f9a93551b3bf63aff47e8d76b38bf42e384de0937fced0f64
+  data.tar.gz: fedcc1df590836fc6e55e7e41bb1527300f05ce0c3b12faf5b32cffcecd607b0f36dd0739b787a64fcddf45e6da78a693b6706d86bc8e9707e9c073ff52679b7

data/.rubocop.yml

@@ -9,6 +9,15 @@ Style/StringLiteralsInInterpolation:
   Enabled: true
   EnforcedStyle: double_quotes
 
+Style/HashTransformKeys:
+  Enabled: true
+
+Style/HashTransformValues:
+  Enabled: true
+
+Style/HashEachMethods:
+ Enabled: true 
+
 Metrics/MethodLength:
   Max: 15
 

data/README.md

@@ -4,11 +4,11 @@ It is a rule-based engine with custom rules to Analyze Active-Record relations u
 
 ## Installation
 
-Install the gem and add to the application's Gemfile by executing:
+Install the gem and add it to the application's Gemfile by executing:
 
     $ bundle add query_police
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+If the bundler is not being used to manage dependencies, install the gem by executing:
 
     $ gem install query_police
 
@@ -28,8 +28,7 @@ puts analysis.pretty_analysis_for(<impact>)
 **Eg.** 
 ```
 analysis = QueryPolice.analyse(
-  User.joins('join sessions on sessions.user_email = users.email ')
-  .where('sessions.created_at < ?', Time.now - 5.months).order('sessions.created_at')
+  User.joins('join orders on orders.user_id = users.id')
 )
 puts analysis.pretty_analysis_for('negative')
 # or
@@ -38,22 +37,45 @@ puts analysis.pretty_analysis({'negative' => true, 'positive' => true})
 **Results**
 
 ```
-table: sessions
-column: type
-impact: negative
-message: Entire sessions table is scanned to find matching rows, you have 1 possible keys to use.
-suggestion: Use index here. You can use index from possible key: ["index_sessions_on_user_email"] or add new one to sessions table as per the requirements.
-column: key
-impact: negative
-message: There is no index key used for sessions table, and can result into full scan of the sessions table
-suggestion: Please use index from possible_keys: ["index_sessions_on_user_email"] or add new one to sessions table as per the requirements.
-column: rows
-impact: negative
-message: 2982924 rows are being scanned per join for sessions table.
-suggestion: Please see if it is possible to use index from ["index_sessions_on_user_email"] or add new one to sessions table as per the requirements to reduce the number of rows scanned.
-```
-
-### Add logger for every query
+query_score: 330.0
+
++----------------------------------------------------------------------------------------------------------------------------------+
+|                                                              orders                                                              |
++------------+---------------------------------------------------------------------------------------------------------------------+
+| score      | 200.0                                                                                                               |
++------------+---------------------------------------------------------------------------------------------------------------------+
+| column     | type                                                                                                                |
+| impact     | negative                                                                                                            |
+| tag_score  | 100.0                                                                                                               |
+| message    | Entire orders table is scanned to find matching rows, you have 0 possible keys to use.                              |
+| suggestion | Use index here. You can use index from possible key: absent or add new one to orders table as per the requirements. |
++------------+---------------------------------------------------------------------------------------------------------------------+
+| column     | possible_keys                                                                                                       |
+| impact     | negative                                                                                                            |
+| tag_score  | 50.0                                                                                                                |
+| message    | There are no possible keys for orders table to be used, can result into full scan                                   |
+| suggestion | Please add index keys for orders table                                                                              |
++------------+---------------------------------------------------------------------------------------------------------------------+
+| column     | key                                                                                                                 |
+| impact     | negative                                                                                                            |
+| tag_score  | 50.0                                                                                                                |
+| message    | There is no index key used for orders table, and can result into full scan of the orders table                      |
+| suggestion | Please use index from possible_keys: absent or add new one to orders table as per the requirements.                 |
++------------+---------------------------------------------------------------------------------------------------------------------+
++------------------------------------------------------------------------------------+
+|                                       users                                        |
++------------+-----------------------------------------------------------------------+
+| score      | 130.0                                                                 |
++------------+-----------------------------------------------------------------------+
+| column     | detailed#used_columns                                                 |
+| impact     | negative                                                              |
+| tag_score  | 130.0                                                                 |
+| message    | You have selected 18 columns, You should not select too many columns. |
+| suggestion | Please only select required columns.                                  |
++------------+-----------------------------------------------------------------------+
+```
+
+### Add a logger for every query
 
 Add `QueryPolice.subscribe_logger` to your initial load file like `application.rb`
 
@@ -61,24 +83,24 @@ You can make logger silence of error using `QueryPolice.subscribe_logger silent:
 
 You can change logger config using `QueryPolice logger_config: <config>`, default logger_config `{'negative' => true}`, options `positive: <Boolean>, caution: <Boolean>`.
 
-
+---
 
 ## How it works?
 
-1. Query police converts the relation into sql query
+1. Query police converts the relation into SQL query
 
-2. Query police generates execution plan using EXPLAIN and EXPLAIN format=JSON based on the configuration.
+2. Query police generates an execution plan using EXPLAIN and EXPLAIN format=JSON based on the configuration.
 
 3. Query police load rules from the config file.
 
 4. Query police apply rules on the execution plan and generate a new analysis object.
 
-5. Analysis object provide different methods to print the analysis in more descriptive format.
+5. Analysis object provides different methods to print the analysis in a more descriptive format.
 
 
 ## Execution plan
 
-We have 2 possible execution plan:-
+We have 2 possible execution plans:-
 
 Normal - using `EXPLAIN`
 
@@ -98,7 +120,7 @@ Generated using `EXPAIN <query>`
 |  1 | SIMPLE      | users   | NULL       | eq_ref | PRIMARY,index_users_on_id | PRIMARY             | 4       | development.profile.user_id |1     |  100.00  | NULL                     |
 
 
-Result for this is added as it is in the final execution plan
+The result for this is added as it is in the final execution plan
 
 **Eg.**
 
@@ -172,7 +194,7 @@ Generated using `EXPAIN format=JSON <query>`
 ```
 
 
-Result for this is added in flatten form to final execution plan, where `detailed#` prefix is added before each key.
+The result for this is added in the flattened form to the final execution plan, where the `detailed#` prefix is added before each key.
 
 **Truncated Eg.**
 
@@ -200,27 +222,27 @@ Result for this is added in flatten form to final execution plan, where `detaile
 
 ## Analysis object
 
-Analysis object stores a detailed analysis report of a relation inside `:tables :table_count :summary attributes`.
+Analysis object stores a detailed analysis report of a relation inside `:tables :summary attributes`.
 
 #### Attributes
 
-**table_count [Integer]  - No. Tables used in the relation**
-
 **tables [Hash] - detailed table analysis**
 
 ```
 {
   'users' => {                        
     'id'=>1,                    
-    'name'=>'users',                 # table alias user in the execution plan
-    'analysis'=>{
-      'type'=>{                      # attribute name
+    'name' => 'users',               # table alias user in the execution plan
+    'score' => <float>               # score for the table   
+    'analysis' => {
+      'type' => {                    # attribute name
         'value' => <string>,         # raw value of attribute in execution plan
         'tags' => {
           'all' => {                 # tag based on the value of a attribute
             'impact'=> <string>,     # negative, positive, cautions
             'warning'=> <string>,    # Eg. 'warning to represent the issue'
-            'suggestions'=> <string> # Eg. 'some follow up suggestions'
+            'suggestions'=> <string> # Eg. 'some follow-up suggestions'
+            'score' => <float>       # score for the tag
           }
         }
       }
@@ -232,10 +254,11 @@ Analysis object stores a detailed analysis report of a relation inside `:tables
 
 ```
 {
-  'cardinality'=>{
-    'amount'=>10,
-    'warning'=>'warning to represent the issue',
-    'suggestions'=>'some follow up suggestions'
+  'cardinality' => {
+    'amount' => 10,
+    'warning' => 'warning to represent the issue',
+    'suggestions' => 'some follow up suggestions',
+    'score' => 100.0
   }
 }
 ```
@@ -261,7 +284,11 @@ A basic rule structure -
       "amount": <integer>
       "impact": <string>,
       "message": <string>,
-      "suggestion": <string> 
+      "suggestion": <string>,
+      "score": {
+        "value": <integer>,
+        "type": <string>
+      } 
     }
   }
 }
@@ -278,19 +305,19 @@ A basic rule structure -
 
     - `<tag>` - direct value match eg. ALL, SIMPLE
 
-    - `absent` - when value is missing
+    - `absent` - when the value is missing
 
     - `threshold` - a greater than threshold check based on the amount set inside the rule.
 
-- `amount` - amount of threshold need to check for 
+- `amount` - the amount of threshold that needs to check for 
 
     - length for string
 
     - value for number
 
-    - size for array
+    - size for the array
 
-- `impact` - impact for the rule
+- `impact` - impact of the rule
 
     - `negative`
 
@@ -298,23 +325,29 @@ A basic rule structure -
 
     - `caution`
 
-- `message` - message need to provide the significance of the rule
+- `message` - the message needs to provide the significance of the rule
 
 - `suggestion` - suggestion on how we can fix the issue
+- `score` - score-related config that will be affected to final query score
+    - `value` - value that will be added to the query score 
+    -  `type` - the type of scoring that will be added to the query score
+        - `base`- value
+        - `relative` - value * (amount for that column in query)
+        - `treshold_relative` - (value - (threshold amount)) * (amount for that column in query)
 
 
 
 ### Dynamic messages and suggestion
 
-We can define dynamic messages and suggestion with variables provided by the engine.
+We can define dynamic messages and suggestions with variables provided by the engine.
 
-- `$amount` - amount of the value 
+- `$amount` - the amount of the value 
 
     - length for string
 
     - value for number
 
-    - size for array
+    - size for the array
 
 - `$column` - attribute name
 
@@ -326,7 +359,7 @@ We can define dynamic messages and suggestion with variables provided by the eng
 
 - `$value` - original parsed value
 
-- `$<column_name>` - value of that specific column in that table
+- `$<column_name>` - the value of that specific column in that table
 
 - `$amount_<column_name>` - amount of that specific column
 
@@ -349,15 +382,19 @@ We can define dynamic messages and suggestion with variables provided by the eng
     "ALL": {
       "impact": "negative",
       "message": "Entire $table table is scanned to find matching rows, you have $amount_possible_keys possible keys to use.",
-      "suggestion": "Use index here. You can use index from possible key: $possible_keys or add new one to $table table as per the requirements."
+      "suggestion": "Use index here. You can use index from possible key: $possible_keys or add new one to $table table as per the requirements.",
+      "score": {
+        "value": 200,
+        "type": "base" 
+      }
     }
 }
 ```
-For above rule dynamic message will be generated as-
+For the above rule, dynamic message will be generated as-
 ```
 Entire users table is scanned to find matching rows, you have 1 possible keys to use
 ```
-For above rule dynamic suggestion will be generated as-
+For the above rule, dynamic suggestion will be generated as-
 ```
 Use index here. You can use index from possible key: ["PRIMARY", "user_email"] or add new one to users table as per the requirements.
 ```
@@ -379,11 +416,11 @@ Use index here. You can use index from possible key: ["PRIMARY", "user_email"] o
 }
 ```
 
-For above rule dynamic message will be generated as-
+For the above rule, dynamic message will be generated as-
 ```
 There is no index key used for users table, and can result into full scan of the users table
 ```
-For above rule dynamic suggestion will be generated as-
+For the above rule, dynamic suggestion will be generated as-
 ```
 Please use index from possible_keys: ["PRIMARY", "user_email"] or add new one to users table as per the requirements.
 ```
@@ -406,11 +443,11 @@ Please use index from possible_keys: ["PRIMARY", "user_email"] or add new one to
   }
 }
 ```
-For above rule dynamic message will be generated as-
+For the above rule, dynamic message will be generated as-
 ```
 There are 10 possible keys for users table, having too many index keys can be unoptimal
 ```
-For above rule dynamic suggestion will be generated as-
+For the above rule, dynamic suggestion will be generated as-
 ```
 Please check if there are extra indexes in users table.
 ```
@@ -427,16 +464,20 @@ Please check if there are extra indexes in users table.
       "amount": 7,
       "impact": "negative",
       "message": "You have selected $amount columns, You should not select too many columns.",
-      "suggestion": "Please only select required columns." 
+      "suggestion": "Please only select required columns.",
+      "score": {
+        "value": 10,
+        "type": "treshold_relative" 
+      }
     }
   }
 }
 ```
-For above rule dynamic message will be generated as-
+For the above rule, dynamic message will be generated as-
 ```
 You have selected 10 columns, You should not select too many columns.
 ```
-For above rule dynamic suggestion will be generated as-
+For the above rule, dynamic suggestions will be generated as-
 ```
 Please only select required columns.
 ```
@@ -444,24 +485,24 @@ Please only select required columns.
 
 ### Summary
 
-You can define similar rules for summary. Current summary attribute supported - 
+You can define similar rules for the summary. Current summary attribute supported - 
 
-- `cardinality` - cardinality based on the all tables
+- `cardinality` - cardinality based on all tables
 
-**NOTE:** You can add custom summary attributes by defining how to calculate them in `QueryPolice.add_summary` for a attribute key.
+**NOTE:** You can add custom summary attributes by defining how to calculate them in `QueryPolice.add_summary` for an attribute key.
 
 
 
 ### Attributes
 
-There all lot of attributes for you to use based on the final execution plan. 
+There are a lot of attributes for you to use based on the final execution plan. 
 
-You can use normal execution plan attribute directly.
+You can use the normal execution plan attribute directly.
 Eg. `select_type, type, Extra, possible_keys`
 
 To check more keys you can use `EXPLAIN <query>`
 
-You can use detailed execution plan attribute can be used in flatten form with `detailed#` prefix.
+You can use the detailed execution plan attribute can be used in flattened form with the `detailed#` prefix.
 Eg. `detailed#used_columns, detailed#cost_info#read_cost`
 
 To check more keys you can use `EXPLAIN format=JSON <query>`
@@ -484,4 +525,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the QueryPolice project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/query_police/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the QueryPolice project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/query_police/blob/master/CODE_OF_CONDUCT.md).

data/lib/query_police/analyse.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# QueryPolice::Analyse
+module QueryPolice
+  # This module define analyse methods for query police
+  module Analyse
+    def table(table, summary, rules_config)
+      table_analysis = {}
+      table_score = 0
+
+      table.each do |column, value|
+        summary = add_summary(summary, column, value)
+        next unless rules_config.dig(column).present?
+
+        table_analysis.merge!({ column => apply_rules(rules_config.dig(column), value) })
+        table_score += table_analysis.dig(column, "tags").map { |_, tag| tag.dig("score") }.sum.to_f
+      end
+
+      [table_analysis, summary, table_score]
+    end
+
+    def generate_summary(rules_config, summary)
+      summary_analysis = {}
+      summary_score = 0
+
+      summary.each do |column, value|
+        next unless rules_config.dig(column).present?
+
+        summary_analysis.merge!({ column => apply_rules(rules_config.dig(column), value) })
+        summary_score += summary_analysis.dig(column, "tags").map { |_, tag| tag.dig("score") }.sum.to_f
+      end
+
+      [summary_analysis, summary_score]
+    end
+
+    class << self
+      private
+
+      def add_summary(summary, column_name, value)
+        summary["cardinality"] = (summary.dig("cardinality") || 1) + value.to_f if column_name.eql?("rows")
+
+        summary
+      end
+
+      def apply_rules(column_rules, value)
+        column_rules = Constants::DEFAULT_COLUMN_RULES.merge(column_rules)
+        value = Transform.value(value, column_rules)
+        amount = Transform.amount(value, column_rules)
+
+        column_analyse = { "value" => value, "amount" => amount, "tags" => {} }
+
+        [*value].each do |tag|
+          tag_rule = column_rules.dig("rules", tag)
+          next unless tag_rule.present?
+
+          column_analyse["tags"].merge!(
+            { tag => Transform.tag_rule(tag_rule).merge!({ "score" => generate_score(tag_rule, amount) }) }
+          )
+        end
+
+        column_analyse["tags"].merge!(apply_threshold_rule(column_rules, amount))
+
+        column_analyse
+      end
+
+      def apply_threshold_rule(column_rules, amount)
+        threshold_rule = column_rules.dig("rules", "threshold")
+
+        if threshold_rule.present? && amount >= threshold_rule.dig("amount")
+          return {
+            "threshold" => Transform.tag_rule(threshold_rule).merge(
+              { "amount" => amount, "score" => generate_score(threshold_rule, amount) }
+            )
+          }
+        end
+
+        {}
+      end
+
+      def generate_score(tag_rule, amount)
+        score = tag_rule.dig("score", "value")
+
+        case tag_rule.dig("score", "type").to_s
+        when "base"
+          score.to_f
+        when "relative"
+          amount.to_f * score.to_f
+        when "treshold_relative"
+          (amount - tag_rule.dig("amount")).to_f * score.to_f
+        else
+          0
+        end
+      end
+    end
+
+    module_function :table, :generate_summary
+  end
+
+  private_constant :Analyse
+end

data/lib/query_police/analysis/dynamic_message.rb

@@ -14,13 +14,13 @@ module QueryPolice
       # @return [String]
       def dynamic_message(opts)
         table, column, tag, type = opts.values_at("table", "column", "tag", "type")
-        message = tables.dig(table, "analysis", column, "tags", tag, type) || ""
+        message = query_analytic.dig(table, "analysis", column, "tags", tag, type) || ""
 
         variables = message.scan(/\$(\w+)/).uniq.map { |var| var[0] }
         variables.each do |var|
           value = dynamic_value_of(var, opts)
 
-          message.gsub!(/\$#{var}/, value.to_s) if value.present?
+          message = message.gsub(/\$#{var}/, value.to_s) unless value.nil?
         end
 
         message
@@ -32,14 +32,14 @@ module QueryPolice
 
       def relative_value_of(var, table)
         value_type = var.match(/amount_/).present? ? "amount" : "value"
-        tables.dig(table, "analysis", var.gsub(/amount_/, ""), value_type)
+        query_analytic.dig(table, "analysis", var.gsub(/amount_/, ""), value_type)
       end
 
       # dynamic variable methods
       def amount(opts)
         table, column = opts.values_at("table", "column")
 
-        tables.dig(table, "analysis", column, "amount")
+        query_analytic.dig(table, "analysis", column, "amount")
       end
 
       def column(opts)
@@ -49,9 +49,18 @@ module QueryPolice
       def impact(opts)
         table, column, tag = opts.values_at("table", "column", "tag")
 
-        impact = tables.dig(table, "analysis", column, "tags", tag, "impact")
+        impact = query_analytic.dig(table, "analysis", column, "tags", tag, "impact")
 
-        opts.dig("colours").present? ? impact.send(IMPACTS[impact].colour) : impact
+        opts.dig("colours").present? ? impact.send(IMPACTS.dig(impact, "colour")) : impact
+      end
+
+      def score(opts)
+        table, column, tag = opts.values_at("table", "column", "tag")
+
+        impact = query_analytic.dig(table, "analysis", column, "tags", tag, "impact")
+        score = query_analytic.dig(table, "analysis", column, "tags", tag, "score")
+
+        opts.dig("colours").present? ? score.to_s.send(IMPACTS.dig(impact, "colour")) : score
       end
 
       def table(opts)
@@ -65,7 +74,7 @@ module QueryPolice
       def value(opts)
         table, column = opts.values_at("table", "column")
 
-        tables.dig(table, "analysis", column, "value")
+        query_analytic.dig(table, "analysis", column, "value")
       end
     end
   end

data/lib/query_police/analysis.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "analysis/dynamic_message"
+require_relative "helper"
 
 module QueryPolice
   # This class is used to store analysis of a query and provide methods over them
@@ -18,16 +19,18 @@ module QueryPolice
     # Eg.
     # {
     #   "users" => {
-    #     "id"=>1,
-    #     "name"=>"users",
-    #     "analysis"=>{
-    #       "type"=>{
-    #         "value" => "all",
+    #     "id" => 1,
+    #     "name" => "users",
+    #     "score" => 100.0,
+    #     "analysis" => {
+    #       "type" => {
+    #         "value" => all",
     #         "tags" => {
     #           "all" => {
-    #             "impact"=>"negative",
-    #             "warning"=>"warning to represent the issue",
-    #             "suggestions"=>"some follow up suggestions"
+    #             "impact" => "negative",
+    #             "warning" => "warning to represent the issue",
+    #             "suggestions" => "some follow up suggestions",
+    #             "score" => 100.0
     #           }
     #         }
     #       }
@@ -37,55 +40,65 @@ module QueryPolice
     # summary [Hash] hash of analysis summary
     # Eg.
     #  {
-    #    "cardinality"=>{
-    #      "amount"=>10,
-    #      "warning"=>"warning to represent the issue",
-    #      "suggestions"=>"some follow up suggestions"
+    #    "cardinality" => {
+    #      "amount" => 10,
+    #      "warning" => "warning to represent the issue",
+    #      "suggestions" => "some follow up suggestions",
+    #      "score" => 100.0
     #    }
     #  }
     def initialize
       @table_count = 0
       @tables = {}
+      @table_score = 0
       @summary = {}
+      @summary_score = 0
     end
 
-    attr_accessor :table_count, :tables, :summary
+    attr_accessor :tables, :summary
 
     # register a table analysis in analysis object
     # @param name [String] name of the table
     # @param table_analysis [Hash] analysis of a table
+    # @param score [Integer] score for that table
     # Eg.
     #  {
-    #    "id"=>1,
-    #    "name"=>"users",
-    #    "analysis"=>{
-    #      "type"=>[
+    #    "id" => 1,
+    #    "name" => "users",
+    #    "score" => 100.0
+    #    "analysis" => {
+    #      "type" => [
     #        {
-    #          "tag"=>"all",
-    #          "impact"=>"negative",
-    #          "warning"=>"warning to represent the issue",
-    #          "suggestions"=>"some follow up suggestions"
+    #          "tag" => "all",
+    #          "impact" => "negative",
+    #          "warning" => "warning to represent the issue",
+    #          "suggestions" => "some follow up suggestions",
+    #          "score" => 100.0
     #        }
     #      ]
     #    }
     #  }
-    def register_table(name, table_analysis)
-      self.table_count += 1
+    def register_table(name, table_analysis, score)
+      @table_count += 1
       tables.merge!(
         {
           name => {
-            "id" => self.table_count,
+            "id" => @table_count,
             "name" => name,
+            "score" => score,
             "analysis" => table_analysis
           }
         }
       )
+
+      @table_score += score
     end
 
     # register summary based in different attributes
     # @param summary [Hash] hash of summary of analysis
-    def register_summary(summary)
+    def register_summary(summary, score)
       self.summary.merge!(summary)
+      @summary_score += score
     end
 
     # to get analysis in pretty format with warnings and suggestions
@@ -93,6 +106,7 @@ module QueryPolice
     # @return [String] pretty analysis
     def pretty_analysis(opts)
       final_message = ""
+      opts = opts.with_indifferent_access
 
       opts.slice(*IMPACTS.keys).each do |impact, value|
         final_message += pretty_analysis_for(impact) if value.present?
@@ -105,49 +119,80 @@ module QueryPolice
     # @param impact [String]
     # @return [String] pretty analysis
     def pretty_analysis_for(impact)
-      final_message = ""
+      final_message = "query_score: #{query_score}\n\n"
 
-      tables.keys.each do |table|
-        table_message = table_pretty_analysis(table, { impact => true })
+      query_analytic.each_key do |table|
+        table_message = query_pretty_analysis(table, { impact => true })
 
-        final_message += "table: #{table}\n#{table_message}\n" if table_message.present?
+        final_message += "#{table_message}\n" if table_message.present?
       end
 
       final_message
     end
 
+    # to get the final score
+    def query_score
+      @table_score + @summary_score
+    end
+
     # to get analysis in pretty format with warnings and suggestions for a table
     # @param table [String] - table name
     # @param opts [Hash] - possible options [positive: <boolean>, negative: <boolean>, caution: <boolean>]
     # @return [String] pretty analysis
-    def table_pretty_analysis(table, opts)
-      table_message = ""
+    def query_pretty_analysis(table, opts)
+      table_analytics = Terminal::Table.new(title: table)
+      table_analytics_present = false
+      table_analytics.add_row(["score", query_analytic.dig(table, "score")])
 
-      tables.dig(table, "analysis").each do |column, column_analysis|
-        tags_message = ""
-        column_analysis.dig("tags").each do |tag, tag_analysis|
-          next unless opts.dig(tag_analysis.dig("impact")).present?
+      opts = opts.with_indifferent_access
 
-          tags_message += tag_pretty_analysis(table, column, tag)
-        end
+      query_analytic.dig(table, "analysis").each do |column, _|
+        column_analytics = column_analytic(table, column, opts)
+        next unless column_analytics.present?
 
-        table_message += "column: #{column}\n#{tags_message}" if tags_message.present?
+        table_analytics_present = true
+        table_analytics.add_separator
+        table_analytics.add_row(["column", column])
+        column_analytics.each { |row| table_analytics.add_row(row) }
       end
 
-      table_message
+      table_analytics_present ? table_analytics : nil
     end
 
     private
 
-    def tag_pretty_analysis(table, column, tag)
-      tag_message = ""
+    def column_analytic(table, column, opts)
+      column_analytics = []
+
+      query_analytic.dig(table, "analysis", column, "tags").each do |tag, tag_analysis|
+        next unless opts.dig(tag_analysis.dig("impact")).present?
+
+        column_analytics += tag_analytic(table, column, tag)
+      end
+
+      column_analytics
+    end
+
+    def query_analytic
+      tables.merge(
+        "summary" => {
+          "name" => "summary",
+          "score" => @summary_score,
+          "analysis" => summary
+        }
+      )
+    end
+
+    def tag_analytic(table, column, tag)
+      tag_message = []
 
       opts = { "table" => table, "column" => column, "tag" => tag }
       message = dynamic_message(opts.merge({ "type" => "message" }))
       suggestion = dynamic_message(opts.merge({ "type" => "suggestion" }))
-      tag_message += "impact: #{impact(opts.merge({ "colours" => true }))}\n"
-      tag_message += "message: #{message}\n"
-      tag_message += "suggestion: #{suggestion}\n" if suggestion.present?
+      tag_message << ["impact", impact(opts.merge({ "colours" => true }))]
+      tag_message << ["tag_score", score(opts.merge({ "colours" => true }))]
+      tag_message << ["message", Helper.word_wrap(message)]
+      tag_message << ["suggestion", Helper.word_wrap(suggestion)] if suggestion.present?
 
       tag_message
     end

data/lib/query_police/helper.rb

@@ -34,7 +34,20 @@ module QueryPolice
       JSON.parse(File.read(rules_path))
     end
 
-    module_function :flatten_hash, :logger, :load_config
+    def word_wrap(string, width = 100)
+      words = string.split
+      wrapped_string = " "
+
+      words.each do |word|
+        last_line_size = (wrapped_string.split("\n")[-1]&.size || 0)
+        wrapped_string = wrapped_string.strip + "\n" if (last_line_size + word.size) > width
+        wrapped_string += "#{word} "
+      end
+
+      wrapped_string.strip
+    end
+
+    module_function :flatten_hash, :logger, :load_config, :word_wrap
   end
 
   private_constant :Helper

data/lib/query_police/rules.json

@@ -62,7 +62,11 @@
       "ALL": {
         "impact": "negative",
         "message": "Entire $table table is scanned to find matching rows, you have $amount_possible_keys possible keys to use.",
-        "suggestion": "Use index here. You can use index from possible key: $possible_keys or add new one to $table table as per the requirements."
+        "suggestion": "Use index here. You can use index from possible key: $possible_keys or add new one to $table table as per the requirements.",
+        "score": {
+          "value": 100,
+          "type": "base"
+        }
       }
     }
   },
@@ -86,13 +90,21 @@
       "absent": {
         "impact": "negative",
         "message": "There are no possible keys for $table table to be used, can result into full scan",
-        "suggestion": "Please add index keys for $table table"
+        "suggestion": "Please add index keys for $table table",
+        "score": {
+          "value": 50,
+          "type": "base"
+        }
       },
       "threshold": {
         "amount": 5,
         "impact": "negative",
         "message": "There are $amount possible keys for $table table, having too many index keys can be unoptimal",
-        "suggestion": "Please check if there are extra indexes in $table table."
+        "suggestion": "Please check if there are extra indexes in $table table.",
+        "score": {
+          "value": 20,
+          "type": "treshold_relative"
+        }
       }
     }
   },
@@ -103,7 +115,11 @@
       "absent": {
         "impact": "negative",
         "message": "There is no index key used for $table table, and can result into full scan of the $table table",
-        "suggestion": "Please use index from possible_keys: $possible_keys or add new one to $table table as per the requirements."
+        "suggestion": "Please use index from possible_keys: $possible_keys or add new one to $table table as per the requirements.",
+        "score": {
+          "value": 50,
+          "type": "base"
+        }
       }
     }
   },
@@ -122,15 +138,14 @@
     "value_type": "array",
     "delimiter": ";",
     "rules": {
-      "Using temporary": {
-        "impact": "",
-        "message": "",
-        "suggestion": ""
-      },
       "Using filesort": {
         "impact": "negative",
         "message": "A file-based algorithm in being applied over your result, This can be inefficient and result into long query time.",
-        "suggestion": "Please ensure either result set is small or use proper index."
+        "suggestion": "Please ensure either result set is small or use proper index.",
+        "score": {
+          "value": 50,
+          "type": "base"
+        }
       },
       "Using join buffer": {
         "impact": "",
@@ -145,26 +160,50 @@
     }
   },
   "detailed#used_columns": {
-    "description": "",
+    "description": "number of column used to execute the query",
     "value_type": "array",
     "rules": {
       "threshold": {
-        "amount": 7,
+        "amount": 5,
         "impact": "negative",
         "message": "You have selected $amount columns, You should not select too many columns.",
-        "suggestion": "Please only select required columns."
+        "suggestion": "Please only select required columns.",
+        "score": {
+          "value": 10,
+          "type": "treshold_relative"
+        }
       }
     }
   },
-  "cardinality": {
-    "description": "",
+  "detailed#cost_info#read_cost ": {
+    "description": "read cost to execute the query",
     "value_type": "number",
     "rules": {
       "threshold": {
         "amount": 100,
         "impact": "negative",
+        "message": "The read cost of query is to high, most likely you are scanning to many rows",
+        "suggestion": "Please use proper index, query only requried data and ensure you are using proper joins.",
+        "score": {
+          "value": 0.01,
+          "type": "relative"
+        }
+      }
+    }
+  },
+  "cardinality": {
+    "description": "total cardinality of the query",
+    "value_type": "number",
+    "rules": {
+      "threshold": {
+        "amount": 500,
+        "impact": "negative",
         "message": "The cardinality of table is $amount, and its too high.",
-        "suggestion": "Please use proper index, query only requried data and ensure you are using proper joins."
+        "suggestion": "Please use proper index, query only requried data and ensure you are using proper joins.",
+        "score": {
+          "value": 0.01,
+          "type": "relative"
+        }
       }
     }
   }

data/lib/query_police/transform.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# QueryPolice::Transform
+module QueryPolice
+  # This module define transformer methods for query police
+  module Transform
+    def amount(value, column_rules)
+      return 0 if value.eql?("absent")
+
+      column_rules.dig("value_type").eql?("number") ? value.to_f : value.size
+    end
+
+    def tag_rule(tag_rule)
+      tag_rule.slice("impact", "suggestion", "message")
+    end
+
+    def value(value, column_rules)
+      return "absent" if value.nil?
+
+      if column_rules.dig("value_type").eql?("array") && column_rules.dig("delimiter").present?
+        value = value.split(column_rules.dig("delimiter")).map(&:strip)
+      end
+
+      value
+    end
+
+    module_function :amount, :tag_rule, :value
+  end
+
+  private_constant :Transform
+end

data/lib/query_police/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module QueryPolice
-  VERSION = "0.1.2.beta"
+  VERSION = "0.1.4.beta"
 end

data/lib/query_police.rb

@@ -3,14 +3,18 @@
 require "active_record"
 require "active_support/notifications"
 require "active_support/core_ext"
-require "json"
+require "colorize"
 require "forwardable"
+require "json"
+require "terminal-table"
 
+require_relative "query_police/analyse"
 require_relative "query_police/analysis"
-require_relative "query_police/constants"
 require_relative "query_police/config"
+require_relative "query_police/constants"
 require_relative "query_police/explain"
 require_relative "query_police/helper"
+require_relative "query_police/transform"
 require_relative "query_police/version"
 
 # This module provides tools to analyse your queries based on custom rules
@@ -40,12 +44,12 @@ module QueryPolice
     query_plan = Explain.full_explain(relation, config.detailed?)
 
     query_plan.each do |table|
-      table_analysis, summary = analyse_table(table, summary, rules_config)
+      table_analysis, summary, table_score = Analyse.table(table, summary, rules_config)
 
-      analysis.register_table(table.dig("table"), table_analysis)
+      analysis.register_table(table.dig("table"), table_analysis, table_score)
     end
 
-    analysis.register_summary(generate_summary_analysis(rules_config, summary))
+    analysis.register_summary(*Analyse.generate_summary(rules_config, summary))
 
     analysis
   end
@@ -71,90 +75,6 @@ module QueryPolice
 
   class << self
     attr_accessor :config
-
-    private
-
-    def add_summary(summary, column_name, value)
-      summary["cardinality"] = (summary.dig("cardinality") || 1) + value.to_f if column_name.eql?("rows")
-
-      summary
-    end
-
-    def analyse_table(table, summary, rules_config)
-      table_analysis = {}
-
-      table.each do |column, value|
-        summary = add_summary(summary, column, value)
-        next unless rules_config.dig(column).present?
-
-        table_analysis.merge!({ column => apply_rules(rules_config.dig(column), value) })
-      end
-
-      [table_analysis, summary]
-    end
-
-    def apply_rules(column_rules, value)
-      column_rules = Constants::DEFAULT_COLUMN_RULES.merge(column_rules)
-      value = transform_value(value, column_rules)
-      amount = transform_amount(value, column_rules)
-
-      column_analyse = { "value" => value, "amount" => amount, "tags" => {} }
-
-      [*value].each do |tag|
-        tag_rule = column_rules.dig("rules", tag)
-        next unless tag_rule.present?
-
-        column_analyse["tags"].merge!({ tag => transform_tag_rule(tag_rule) })
-      end
-
-      column_analyse["tags"].merge!(apply_threshold_rule(column_rules, amount))
-
-      column_analyse
-    end
-
-    def apply_threshold_rule(column_rules, amount)
-      threshold_rule = column_rules.dig("rules", "threshold")
-
-      if threshold_rule.present? && amount >= threshold_rule.dig("amount")
-        return {
-          "threshold" => transform_tag_rule(threshold_rule).merge(
-            { "amount" => amount }
-          )
-        }
-      end
-
-      {}
-    end
-
-    def generate_summary_analysis(rules_config, summary)
-      summary_analysis = {}
-
-      summary.each do |column, value|
-        next unless rules_config.dig(column).present?
-
-        summary_analysis.merge!({ column => apply_rules(rules_config.dig(column), value) })
-      end
-
-      summary_analysis
-    end
-
-    def transform_amount(value, column_rules)
-      column_rules.dig("value_type").eql?("number") ? value.to_f : value.size
-    end
-
-    def transform_tag_rule(tag_rule)
-      tag_rule.slice("impact", "suggestion", "message")
-    end
-
-    def transform_value(value, column_rules)
-      value ||= "absent"
-
-      if column_rules.dig("value_type").eql?("array") && column_rules.dig("delimiter").present?
-        value = value.split(column_rules.dig("delimiter")).map(&:strip)
-      end
-
-      value
-    end
   end
 
   module_function :analyse, :subscribe_logger, *CONFIG_METHODS

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: query_police
 version: !ruby/object:Gem::Version
-  version: 0.1.2.beta
+  version: 0.1.4.beta
 platform: ruby
 authors:
 - strikeraryu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-04-24 00:00:00.000000000 Z
+date: 2023-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -19,7 +19,7 @@ dependencies:
         version: 3.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 8.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -29,7 +29,7 @@ dependencies:
         version: 3.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 8.0.0
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -39,7 +39,7 @@ dependencies:
         version: 3.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 8.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -49,7 +49,47 @@ dependencies:
         version: 3.0.0
     - - "<"
       - !ruby/object:Gem::Version
-        version: 6.0.0
+        version: 8.0.0
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.0.2
 description: 
 email:
 - striker.aryu56@gmail.com
@@ -66,6 +106,7 @@ files:
 - README.md
 - Rakefile
 - lib/query_police.rb
+- lib/query_police/analyse.rb
 - lib/query_police/analysis.rb
 - lib/query_police/analysis/dynamic_message.rb
 - lib/query_police/config.rb
@@ -73,6 +114,7 @@ files:
 - lib/query_police/explain.rb
 - lib/query_police/helper.rb
 - lib/query_police/rules.json
+- lib/query_police/transform.rb
 - lib/query_police/version.rb
 - sig/query_police.rbs
 homepage: https://github.com/strikeraryu/query_police.git
@@ -100,5 +142,6 @@ requirements: []
 rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
-summary: This gem provides tools to analyze your queries based on custom rules.
+summary: This gem provides tools to analyze your queries based on custom rules and
+  detect bad queries.
 test_files: []