activerecord-analyze 0.7.1 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2021239ed9352a040106ce8c1de50503e785fccd9a3093928eeaf5dfa79a0dc
-  data.tar.gz: 8ba00244e759dc1f31091ec4196aded3887c9007902faf867431ea2ef9ae93dc
+  metadata.gz: 309228bac640cf76afc26a1c224e0e88427e4941e7ab5b5427e9bc969a031b6b
+  data.tar.gz: a71f6053f7562b8e50e86701f7fa37876a732576463c5e0a9d19d85a14615233
 SHA512:
-  metadata.gz: ad2874f8422dc7299b8b7b3036fbec8e90f29780862ea3dd192629894905aafede52731314cc569afb6c9ce31f61a379b31ac308af0c304fc9e72bea583e58a7
-  data.tar.gz: 114236b8af394e3f7fad06549e3bc99fa1814e815dd93282c7d3abfc0a0535ee568d90c0360abab021c83a7f1b38d2bfd0bfec31f043720893ab321776fe83fe
+  metadata.gz: 13f73a221903084b66760dd62bede7d93559c87bb92750c3675843ac97137b99f7f42a61010697e2368527e5c80a27d2cb8352c9bad570f154a1be2b468a81fc
+  data.tar.gz: 38338c77c2829e621529b1fc5c7a7b045fa0d58cf1f12f5e6b19dafbb64af4ad135ea839bf9e3a0292ad6a2e46796c932c6d4a960083e8ea8f274f3ba3c75d88

data/.circleci/config.yml

@@ -16,7 +16,7 @@ jobs:
       - run: gem update --system
       - run: gem install bundler
       - run: bundle install --path vendor/bundle
-      - run: sudo apt-get update
+      - run: sudo apt-get update --allow-releaseinfo-change
       - run: sudo apt install postgresql-client-11
       - run: dockerize -wait tcp://localhost:5432 -timeout 1m
       - run:

data/README.md

@@ -23,21 +23,21 @@ gem 'activerecord-analyze'
 The `analyze` method supports the following EXPLAIN query options ([PostgreSQL docs reference](https://www.postgresql.org/docs/12/sql-explain.html)):
 
 ```
-BUFFERS [ boolean ]
-VERBOSE [ boolean ]
-COSTS [ boolean ]
-SETTINGS [ boolean ]
-TIMING [ boolean ]
-SUMMARY [ boolean ]
-FORMAT { TEXT | XML | JSON | YAML }
+buffers: [ boolean ]
+verbose: [ boolean ]
+costs: [ boolean ]
+settings: [ boolean ]
+timing: [ boolean ]
+summary: [ boolean ]
+format: { :text | :json | :xml | :yaml | :pretty_json }
 ```
 
 You can execute it like that:
 
 ```ruby
 
-User.all.analyze(
-  format: :json,
+puts User.all.analyze(
+  format: :pretty_json, # :pretty_json format option generates a formatted JSON output
   verbose: true,
   costs: true,
   settings: true,
@@ -109,6 +109,43 @@ User.all.analyze(analyze: false)
 
 ```
 
+### Analyzing raw SQL queries
+
+You can also use a raw SQL query string to generate an EXPLAIN ANALYZE output:
+
+```ruby
+query = "SELECT * FROM users WHERE email = 'email@example.com'"
+
+puts ActiveRecordAnalyze.analyze_sql(query, { format: :json})
+
+# [
+# {
+#    "Plan": {
+#      "Node Type": "Seq Scan",
+#      "Parallel Aware": false,
+#      "Relation Name": "users",
+#      "Alias": "users",
+#      "Startup Cost": 0.00,
+#      "Total Cost": 18.75,
+#      "Plan Rows": 4,
+#      "Plan Width": 88,
+#      "Actual Startup Time": 0.010,
+#      "Actual Total Time": 0.018,
+#      "Actual Rows": 0,
+#      "Actual Loops": 1,
+#      "Filter": "((email)::text = 'email@example.com'::text)",
+#      "Rows Removed by Filter": 0
+#    },
+#    "Planning Time": 0.052,
+#    "Triggers": [
+#    ],
+#    "Execution Time": 0.062
+# }
+# ]
+```
+
+This feature is helpful in analyzing SQL queries extracted from the logs.
+
 ### Disclaimer
 
 It is a bit experimental and can break with new Rails release.

data/lib/activerecord-analyze/main.rb

@@ -3,56 +3,7 @@ module ActiveRecord
     module PostgreSQL
       module DatabaseStatements
         def analyze(arel, binds = [], opts = {})
-          format_sql = if fmt = opts[:format].presence
-            case fmt
-            when :json
-              "FORMAT JSON,"
-            when :hash
-              "FORMAT JSON,"
-            when :yaml
-              "FORMAT YAML,"
-            when :text
-              "FORMAT TEXT,"
-            when :xml
-              "FORMAT XML,"
-            end
-          end
-
-          verbose_sql = if opts[:verbose] == true
-            ", VERBOSE"
-          end
-
-          costs_sql = if opts[:costs] == true
-            ", COSTS"
-          end
-
-          settings_sql = if opts[:settings] == true
-            ", SETTINGS"
-          end
-
-          buffers_sql = if opts[:buffers] == true
-            ", BUFFERS"
-          end
-
-          timing_sql = if opts[:timing] == true
-            ", TIMING"
-          end
-
-          summary_sql = if opts[:summary] == true
-            ", SUMMARY"
-          end
-
-          analyze_sql = if opts[:analyze] == false
-            ""
-          else
-            "ANALYZE"
-          end
-
-          opts_sql = "(#{format_sql} #{analyze_sql}#{verbose_sql}#{costs_sql}#{settings_sql}#{buffers_sql}#{timing_sql}#{summary_sql})"
-          .strip.gsub(/\s+/, " ")
-          .gsub(/\(\s?\s?\s?,/, "(")
-          .gsub(/\s,\s/, " ")
-          .gsub(/\(\s?\)/, "")
+          opts_sql = ActiveRecordAnalyze.build_prefix(opts)
 
           sql = "EXPLAIN #{opts_sql} #{to_sql(arel, binds)}"
           PostgreSQL::ExplainPrettyPrinter.new.pp(exec_query(sql, "EXPLAIN #{opts_sql}".strip, binds))
@@ -66,7 +17,7 @@ module ActiveRecord
   class Relation
     def analyze(opts = {})
       res = exec_analyze(collecting_queries_for_explain { exec_queries }, opts)
-      if [:json, :hash].include?(opts[:format])
+      if [:json, :hash, :pretty_json].include?(opts[:format])
         start = res.index("[\n")
         finish = res.rindex("]")
         raw_json = res.slice(start, finish - start + 1)
@@ -75,6 +26,8 @@ module ActiveRecord
           JSON.parse(raw_json).to_json
         elsif opts[:format] == :hash
           JSON.parse(raw_json)
+        elsif opts[:format] == :pretty_json
+          JSON.pretty_generate(JSON.parse(raw_json))
         end
       else
         res

data/lib/activerecord-analyze/version.rb

@@ -1,3 +1,3 @@
 module ActiveRecordAnalyze
-  VERSION = "0.7.1"
+  VERSION = "0.10.0"
 end

data/lib/activerecord-analyze.rb

@@ -1,4 +1,84 @@
+# frozen_string_literal: true
+
 require 'activerecord-analyze/main'
 
 module ActiveRecordAnalyze
+  def self.analyze_sql(raw_sql, opts = {})
+    prefix = "EXPLAIN #{build_prefix(opts)}"
+
+    result = ActiveRecord::Base.connection.execute("#{prefix} #{raw_sql}").to_a
+
+
+    if [:json, :hash, :pretty_json].include?(opts[:format])
+      raw_json = result[0].fetch("QUERY PLAN")
+      if opts[:format] == :json
+        raw_json
+      elsif opts[:format] == :hash
+        JSON.parse(raw_json)
+      elsif opts[:format] == :pretty_json
+        JSON.pretty_generate(JSON.parse(raw_json))
+      end
+    else
+      result.map do |el|
+        el.fetch("QUERY PLAN")
+      end.join("\n")
+    end
+  end
+
+  def self.build_prefix(opts = {})
+    format_sql = if fmt = opts[:format].presence
+      case fmt
+      when :json
+        "FORMAT JSON, "
+      when :hash
+        "FORMAT JSON, "
+      when :pretty_json
+        "FORMAT JSON, "
+      when :yaml
+        "FORMAT YAML, "
+      when :text
+        "FORMAT TEXT, "
+      when :xml
+        "FORMAT XML, "
+      else
+        ""
+      end
+    end
+
+    verbose_sql = if opts[:verbose] == true
+      ", VERBOSE"
+    end
+
+    costs_sql = if opts[:costs] == true
+      ", COSTS"
+    end
+
+    settings_sql = if opts[:settings] == true
+      ", SETTINGS"
+    end
+
+    buffers_sql = if opts[:buffers] == true
+      ", BUFFERS"
+    end
+
+    timing_sql = if opts[:timing] == true
+      ", TIMING"
+    end
+
+    summary_sql = if opts[:summary] == true
+      ", SUMMARY"
+    end
+
+    analyze_sql = if opts[:analyze] == false
+      ""
+    else
+      "ANALYZE"
+    end
+
+    opts_sql = "(#{format_sql}#{analyze_sql}#{verbose_sql}#{costs_sql}#{settings_sql}#{buffers_sql}#{timing_sql}#{summary_sql})"
+      .strip.gsub(/\s+/, " ")
+      .gsub(/\(\s?\s?\s?,/, "(")
+      .gsub(/\s,\s/, " ")
+      .gsub(/\(\s?\)/, "")
+  end
 end

data/spec/analyze_sql_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe "ActiveRecord analyze" do
+  let(:raw_sql) do
+    "SELECT * FROM users WHERE email = 'email@example.com'"
+  end
+
+  let(:result) do
+    ActiveRecordAnalyze.analyze_sql(raw_sql, opts)
+  end
+
+  describe "default opts" do
+    let(:opts) do
+      {}
+    end
+
+    it "works" do
+      expect do
+        result
+      end.not_to raise_error
+    end
+  end
+
+  describe "format json" do
+    let(:opts) do
+      { format: :json }
+    end
+
+    it "works" do
+      puts result
+      expect(JSON.parse(result)[0].keys.sort).to eq [
+        "Execution Time", "Plan", "Planning Time", "Triggers"
+      ]
+    end
+  end
+
+  describe "format hash" do
+    let(:opts) do
+      { format: :hash }
+    end
+
+    it "works" do
+      expect(result[0].keys.sort).to eq [
+        "Execution Time", "Plan", "Planning Time", "Triggers"
+      ]
+    end
+  end
+
+  describe "format pretty" do
+    let(:opts) do
+      { format: :pretty_json }
+    end
+
+    it "works" do
+      expect(JSON.parse(result)[0].keys.sort).to eq [
+        "Execution Time", "Plan", "Planning Time", "Triggers"
+      ]
+    end
+  end
+
+  describe "supports options" do
+    let(:raw_sql) do
+      "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"email\" IS NOT NULL LIMIT 10"
+    end
+
+    let(:opts) do
+      {
+        format: :hash,
+        costs: true,
+        timing: true,
+        summary: true
+      }
+    end
+
+    it "works" do
+      expect(result[0].keys.sort).to eq [
+        "Execution Time", "Plan", "Planning Time", "Triggers"
+      ]
+    end
+  end
+end

data/spec/main_spec.rb

@@ -15,7 +15,7 @@ describe "ActiveRecord analyze" do
     ActiveRecord::Migrator.new(:up, [CreateUsers.new], @schema_migration).migrate
   end
 
-  describe "no opts" do
+  describe "default opts" do
     it "works" do
       expect do
         User.all.analyze
@@ -41,6 +41,15 @@ describe "ActiveRecord analyze" do
     end
   end
 
+  describe "format pretty" do
+    it "works" do
+      result = User.all.analyze(format: :pretty_json)
+      expect(JSON.parse(result)[0].keys.sort).to eq [
+        "Execution Time", "Plan", "Planning Time", "Triggers"
+      ]
+    end
+  end
+
   describe "supports options" do
     it "works" do
       result = User.all.limit(10).where.not(email: nil).analyze(

data/spec/spec_helper.rb

@@ -3,6 +3,18 @@
 require 'rubygems'
 require "active_record/railtie"
 require 'bundler/setup'
+require "migrations/create_users_migration.rb"
 require_relative '../lib/activerecord-analyze'
 
 ENV["DATABASE_URL"] ||= "postgresql://postgres:secret@localhost:5432/activerecord-analyze-test"
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    ActiveRecord::Base.establish_connection(
+      ENV.fetch("DATABASE_URL")
+    )
+
+    @schema_migration = ActiveRecord::Base.connection.schema_migration
+    ActiveRecord::Migrator.new(:up, [CreateUsers.new], @schema_migration).migrate
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-analyze
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.10.0
 platform: ruby
 authors:
 - pawurb
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-09 00:00:00.000000000 Z
+date: 2021-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -86,6 +86,7 @@ files:
 - lib/activerecord-analyze/main.rb
 - lib/activerecord-analyze/version.rb
 - query-plan.png
+- spec/analyze_sql_spec.rb
 - spec/main_spec.rb
 - spec/migrations/create_users_migration.rb
 - spec/spec_helper.rb
@@ -108,11 +109,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.0.3
 signing_key:
 specification_version: 4
 summary: Add EXPLAIN ANALYZE to Active Record query objects
 test_files:
+- spec/analyze_sql_spec.rb
 - spec/main_spec.rb
 - spec/migrations/create_users_migration.rb
 - spec/spec_helper.rb