database_recorder 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd8b63b3fa1b57dd6c2c5cdf501af590f75a5fcb52c322bc4eee702c55026db6
-  data.tar.gz: f2753254f7c7d79ef0fd7dd65e3439197419ae01d96e4625eb3a9f4632835bd9
+  metadata.gz: 5c43f3f7036d73a7133d4a79984dc7035ec2ccfcaccbf23b3e2f36053debc0f5
+  data.tar.gz: 0d8bc0cdf33d2626811f95bfac45b6dfce0383455a39b58940350048c9d92a70
 SHA512:
-  metadata.gz: 343167b893fd491b57405ad465e1b835fcf077d3cc806a4c3a4e6ca7c1253e0967acca90760c30e395de30aa8529421305910f9714879f118892259acf03dbe7
-  data.tar.gz: a2f8defdbd1e9f251afd6c999077870689c20f9c7868cc5d01a2947ab63c3ee1eec2c5401b14eef1378e450dbeb2fb170f93d011e54f8c8e677c150394f0b024
+  metadata.gz: 611e9419ea6c8f1e536c2b0ba5ad19b46327842e15032168c14db5ac8d109cca14a15bf000329538b894851bb51e6ceaf22fc5970356f31f2f3abd182cced339
+  data.tar.gz: 25eba80806a035ca9da8063a1d745e218b3a0851b008fb0b31b3036680c82758210fa596d3386d31daed0bbee72041242150bcadd37337a828918ee511c0fdb1

data/lib/database_recorder/mysql2/client_ext.rb

@@ -4,13 +4,13 @@ module DatabaseRecorder
   module Mysql2
     module ClientExt
       def query(sql, options = {})
-        Recorder.record(self, sql: sql) do
+        Recorder.store_query(self, sql: sql, source: :query) do
           super
         end
       end
 
       def prepare(*args)
-        Recorder.record(self, sql: args[0]) do
+        Recorder.prepare_statement(self, sql: args[0], source: :prepare) do
           super
         end
       end

data/lib/database_recorder/mysql2/recorder.rb

@@ -12,29 +12,16 @@ module DatabaseRecorder
           sql.match?(/information_schema.statistics/)
       end
 
-      def record(adapter, sql:)
-        return yield if ignore_query?(sql)
-
-        Core.log_query(sql)
-        if Config.replay_recordings && !Recording.cache.nil?
-          Recording.push(sql: sql)
-          data = Recording.cached_query_for(sql)
-          return yield unless data # cache miss
+      def format_result(result)
+        { 'count' => result.count, 'fields' => result.fields, 'values' => result.to_a } if result.is_a?(::Mysql2::Result)
+        # else
+        #   last_insert_id = adapter.query('SELECT LAST_INSERT_ID() AS _dbr_last_insert_id').to_a
+        #   { 'count' => last_insert_id.count, 'fields' => ['id'], 'values' => last_insert_id }
+      end
 
-          RecordedResult.new.prepare(data['result'].slice('count', 'fields', 'values')) if data['result']
-        else
-          yield.tap do |result|
-            result_data =
-              if result.is_a? ::Mysql2::Result
-                { 'count' => result.count, 'fields' => result.fields, 'values' => result.to_a }
-                # else
-                #   last_insert_id = adapter.query('SELECT LAST_INSERT_ID() AS _dbr_last_insert_id').to_a
-                #   { 'count' => last_insert_id.count, 'fields' => ['id'], 'values' => last_insert_id }
-              end
-
-            Recording.push(sql: sql, result: result_data)
-          end
-        end
+      def prepare_statement(adapter, sql: nil, name: nil, binds: nil, source: nil)
+        @last_prepared = Recording.push_prepared(name: name, sql: sql, binds: binds, source: source)
+        yield if !Config.replay_recordings || Recording.cache.nil?
       end
 
       def setup
@@ -47,9 +34,38 @@ module DatabaseRecorder
         end
       end
 
-      def update_record(adapter, *args)
-        Recording.update_last(*args)
-        yield
+      def store_prepared_statement(adapter, source:, binds:)
+        # sql = @last_prepared&.send(:[], 'sql')
+        sql = @last_prepared['sql']
+        Core.log_query(sql, source)
+        if Config.replay_recordings && !Recording.cache.nil?
+          data = Recording.cache.find { |query| query['sql'] == sql }
+          return yield unless data # cache miss
+
+          Recording.push(sql: data['sql'], binds: data['binds'], source: source)
+          RecordedResult.new(data['result'].slice('count', 'fields', 'values'))
+        else
+          yield.tap do |result|
+            Recording.update_prepared(sql: sql, binds: binds, result: format_result(result), source: source)
+          end
+        end
+      end
+
+      def store_query(adapter, sql:, source:)
+        return yield if ignore_query?(sql)
+
+        Core.log_query(sql, source)
+        if Config.replay_recordings && !Recording.cache.nil?
+          Recording.push(sql: sql, source: source)
+          data = Recording.cached_query_for(sql)
+          return yield unless data # cache miss
+
+          RecordedResult.new.prepare(data['result'].slice('count', 'fields', 'values')) if data['result']
+        else
+          yield.tap do |result|
+            Recording.push(sql: sql, result: format_result(result), source: source)
+          end
+        end
       end
     end
   end

data/lib/database_recorder/mysql2/statement_ext.rb

@@ -4,7 +4,7 @@ module DatabaseRecorder
   module Mysql2
     module StatementExt
       def execute(*args, **kwargs)
-        Recorder.update_record(self, *args) do
+        Recorder.store_prepared_statement(self, source: :execute, binds: args) do
           super
         end
       end

data/lib/database_recorder/pg/connection_ext.rb

@@ -4,47 +4,43 @@ module DatabaseRecorder
   module PG
     module ConnectionExt
       def async_exec(sql)
-        Recorder.record(sql: sql, source: :async_exec) do
+        Recorder.store_query(sql: sql, source: :async_exec) do
           super
         end
       end
 
       def sync_exec(sql)
-        Recorder.record(sql: sql, source: :sync_exec) do
+        Recorder.store_query(sql: sql, source: :sync_exec) do
           super
         end
       end
 
       def exec(*args)
-        Recorder.record(sql: args[0], source: :exec) do
+        Recorder.store_query(sql: args[0], source: :exec) do
           super
         end
       end
 
-      def query(*args)
-        Recorder.record(sql: args[0], source: :query) do
+      def exec_params(*args)
+        Recorder.store_query(sql: args[0], binds: args[1], source: :exec_params) do
           super
         end
       end
 
-      def exec_params(*args)
-        Recorder.record(sql: args[0], binds: args[1], source: :exec_params) do
+      def exec_prepared(*args)
+        Recorder.store_prepared_statement(name: args[0], binds: args[1], source: :exec_prepared) do
           super
         end
       end
 
-      # def async_exec_params(*args)
-      #   puts ">>> #{args[0]}"
-      #   super
-      # end
-
-      # def sync_exec_params(*args)
-      #   puts ">>> #{args[0]}"
-      #   super
-      # end
+      def prepare(*args)
+        Recorder.prepare_statement(name: args[0], sql: args[1], source: :prepare) do
+          super
+        end
+      end
 
-      def exec_prepared(*args)
-        Recorder.record(sql: args[0], binds: args[1], source: :exec_prepared) do
+      def query(*args)
+        Recorder.store_query(sql: args[0], source: :query) do
           super
         end
       end

data/lib/database_recorder/pg/recorder.rb

@@ -11,29 +11,56 @@ module DatabaseRecorder
           sql.match?(/ pg_attribute |SHOW max_identifier_length|SHOW search_path/)
       end
 
-      def record(sql:, binds: nil, source: nil)
+      def format_result(result)
+        { 'count' => result.count, 'fields' => result.fields, 'values' => result.values } if result
+      end
+
+      def prepare_statement(sql: nil, name: nil, binds: nil, source: nil)
+        Recording.push_prepared(name: name, sql: sql, binds: binds, source: source)
+        yield if !Config.replay_recordings || Recording.cache.nil?
+      end
+
+      def setup
+        ::PG::Connection.class_eval do
+          prepend ConnectionExt
+        end
+      end
+
+      def store_prepared_statement(name: nil, sql: nil, binds: nil, source: nil)
+        if Config.replay_recordings && !Recording.cache.nil?
+          data = Recording.cache.find { |query| query['name'] == name }
+          return yield unless data # cache miss
+
+          Core.log_query(data['sql'], source)
+          Recording.push(sql: data['sql'], binds: data['binds'], source: source)
+          RecordedResult.new(data['result'].slice('count', 'fields', 'values'))
+        else
+          Core.log_query(sql, source)
+          yield.tap do |query_result|
+            result = format_result(query_result)
+            query = Recording.update_prepared(name: name, sql: sql, binds: binds, result: result, source: source)
+            Core.log_query(query['sql'], source)
+          end
+        end
+      end
+
+      def store_query(name: nil, sql: nil, binds: nil, source: nil)
         return yield if ignore_query?(sql)
 
         Core.log_query(sql, source)
+        @prepared_statement = nil
         if Config.replay_recordings && !Recording.cache.nil?
-          Recording.push(sql: sql, binds: binds)
+          Recording.push(sql: sql, binds: binds, source: source)
           data = Recording.cached_query_for(sql)
           return yield unless data # cache miss
 
           RecordedResult.new(data['result'].slice('count', 'fields', 'values'))
         else
           yield.tap do |result|
-            result_data = result ? { 'count' => result.count, 'fields' => result.fields, 'values' => result.values } : nil
-            Recording.push(sql: sql, binds: binds, result: result_data)
+            Recording.push(name: name, sql: sql, binds: binds, result: format_result(result), source: source)
           end
         end
       end
-
-      def setup
-        ::PG::Connection.class_eval do
-          prepend ConnectionExt
-        end
-      end
     end
   end
 end

data/lib/database_recorder/recording.rb

@@ -5,7 +5,7 @@ require 'forwardable'
 module DatabaseRecorder
   class Recording
     attr_accessor :cache, :entities
-    attr_reader :from_cache, :options, :queries, :started
+    attr_reader :from_cache, :options, :prepared_queries, :queries, :started
 
     def initialize(options: {})
       (@@instances ||= {})[Process.pid] = self
@@ -14,6 +14,7 @@ module DatabaseRecorder
       @options = options
       @queries = []
       @search_index = 0
+      @@prepared_queries ||= {}
     end
 
     def cached_query_for(sql)
@@ -38,11 +39,16 @@ module DatabaseRecorder
       @entities.shift
     end
 
-    def push(sql:, binds: nil, result: nil, name: nil)
+    def push(sql:, name: nil, binds: nil, result: nil, source: nil)
       query = { 'name' => name, 'sql' => sql, 'binds' => binds, 'result' => result }.compact
       @queries.push(query)
     end
 
+    def push_prepared(name: nil, sql: nil, binds: nil, result: nil, source: nil)
+      query = { 'name' => name, 'sql' => sql, 'binds' => binds, 'result' => result }.compact
+      @@prepared_queries[name || sql] = query
+    end
+
     def start
       @started = true
       storage = Config.storage&.new(self, name: options[:name])
@@ -55,15 +61,20 @@ module DatabaseRecorder
       result
     end
 
-    def update_last(*args)
-      @queries.last['binds'] = args
+    def update_prepared(name: nil, sql: nil, binds: nil, result: nil, source: nil)
+      query = @@prepared_queries[name || sql]
+      query['sql'] = sql if sql
+      query['binds'] = binds if binds
+      query['result'] = result if result
+      @queries.push(query)
+      query
     end
 
     class << self
       extend Forwardable
 
-      def_delegators :current_instance, :cache, :cached_query_for, :from_cache, :new_entity, :pull_entity, :push,
-                     :queries, :update_last
+      def_delegators :current_instance, :cache, :cached_query_for, :from_cache, :new_entity, :prepared_queries,
+                     :pull_entity, :push, :push_prepared, :queries, :update_prepared
 
       def current_instance
         (@@instances ||= {})[Process.pid]

data/lib/database_recorder/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DatabaseRecorder
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: database_recorder
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Mattia Roccoberton
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-11 00:00:00.000000000 Z
+date: 2022-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coderay