dm-cutie 0.3.16

data/lib/dm-cutie/models/query_storage_link.rb

@@ -0,0 +1,15 @@
+# Link between an generalized query and a repository_storage, has boolean to track if it was the primary storage,
+#   ie, that of the model that generated the query
+
+class QueryStorageLink
+  include DataMapper::Resource
+
+  belongs_to :repository_storage
+  belongs_to :generalized_query
+    
+  property :repository_storage_id,  Integer, :key => true
+  property :generalized_query_id,       Integer, :key => true
+  
+  property :primary_storage, Boolean, :default => true
+  
+end

data/lib/dm-cutie/models/repository_storage.rb

@@ -0,0 +1,67 @@
+require 'digest/sha1'
+
+# Storage information for a particular model & repository
+# This table is a denormalized combination of Repositories and Models
+class RepositoryStorage
+  include DataMapper::Resource
+                                                 
+  has n, :query_storage_links                    
+  
+  after(:save){
+    DataMapper.logger.debug "Created RepositoryStorage ##{self.id}, #{self.signature}"
+  }
+  
+  property :id, Serial                              
+  property :repo_name,    String, :nullable => false
+  property :storage_name, String, :nullable => false
+  property :adapter_name, String, :nullable => false
+  property :model_name,   String, :nullable => false
+  
+  property :record_count, Integer, :nullable => false, :default => 0
+
+  property :signature,    String, :length => 40, :nullable => false, :unique_index => true
+
+  def RepositoryStorage.find_or_make(r,a,s,m)
+    _signature = RepositoryStorage.names_to_signature(r,a,s,m)
+    
+    _rs = RepositoryStorage.first(:signature => _signature) || RepositoryStorage.new
+
+    if _rs.new?
+      _rs.signature     = _signature
+      _rs.repo_name     = r
+      _rs.adapter_name  = a
+      _rs.storage_name  = s
+      _rs.model_name    = m
+      _rs.save
+    end
+    _rs
+  end
+
+  def count_operation(op)
+    GeneralizedQuery.all(GeneralizedQuery.query_storage_links.repository_storage.id => self.id, :operation => op).length
+  end
+  
+  def total_selects
+    @total_selects ||= count_operation(:select)
+  end
+  def total_inserts
+    @total_inserts ||= count_operation(:insert)
+  end
+  def total_deletes
+    @total_deletes ||= count_operation(:delete)
+  end
+  def total_updates
+    @total_updates ||= count_operation(:update)
+  end
+  def read_to_write_ratio
+    "#{total_selects}:#{total_inserts+total_deletes+total_updates}"
+  end
+  
+  # @param r [~String] Repository name
+  # @param s [~String] Storage name 
+  # @param a [~String] Adapter name
+  # @param m [~String] Model name
+  def RepositoryStorage.names_to_signature(r,a,s,m)
+    Digest::SHA1.hexdigest("#{r}>#{a}>#{s}>#{m}")
+  end
+end

data/lib/dm-cutie/tracker/data_objects.rb

@@ -0,0 +1,16 @@
+require 'bigdecimal'
+
+# module DataMapper
+#   module Cutie
+#     module Tracker
+#       module DataObjects
+#       end
+#     end
+#   end
+# end
+
+require DataMapper::Cutie.root / :tracker / :data_objects / :overrides
+require DataMapper::Cutie.root / :tracker / :data_objects / :helper
+
+# DataMapper::Adapters::DataObjectsAdapter.extend DataMapper::Cutie::Tracker::DataObjects::Overrides
+# DataMapper::Adapters::DataObjectsAdapter.extend DataMapper::Cutie::Tracker::DataObjects::Helper

data/lib/dm-cutie/tracker/data_objects/helper.rb

@@ -0,0 +1,85 @@
+require 'bigdecimal'
+#
+# @note: This adds a few helper methods to DataObjectsAdapter
+#
+class DataMapper::Adapters::DataObjectsAdapter
+
+  # This source method is 6 calls deep in apps started with a bin like merb, rails; otherwise, we are looking for the last line
+  #   /Volumes/Workspace/dm-cutie-0.3.13/lib/dm-cutie/tracker/data_objects_adapter_helper.rb:38:in `read'
+  #   /Volumes/Workspace/dm-core-0.10.1/lib/dm-core/adapters/data_objects_adapter.rb:266:in `with_connection'
+  #   /Volumes/Workspace/dm-cutie-0.3.13/lib/dm-cutie/tracker/data_objects_adapter_override.rb:67:in `read'
+  #   /Volumes/Workspace/dm-core-0.10.1/lib/dm-core/repository.rb:141:in `read'
+  #   /Volumes/Workspace/dm-core-0.10.1/lib/dm-core/model.rb:303:in `first'
+  #   /Volumes/Workspace/dm-core-0.10.1/lib/dm-core/model.rb:204:in `get'
+  #   /Volumes/Workspace/dm-cutie-0.3.13/kickstart.rb:50
+  #
+  def _calls_deep;6;end;
+
+  # Accessor for query timers
+  def query_timers;(@__query_timers ||= {});end;
+  
+  # - bind_statement: binds values to a SQL statement
+  # 
+  # @param statement [~String] SQL Statement
+  # @param *bind_values [*splat] Values to bind
+  #
+  # @return [String] Bound SQL Statement
+  #
+  def bind_statement(statement, *bind_values)
+    _ret_stmnt = ''
+    with_connection do |connection|
+      command = connection.create_command(statement)
+      _ret_stmnt = command.send :escape_sql, *bind_values
+    end
+    _ret_stmnt
+  end  
+  
+  def start_tracking_timer(query) 
+    if DataMapper::Cutie.tracking_query?(query)
+      query_timers[query.object_id] = Time.now
+    end
+  end                                        
+  
+  def track_query(query, statement, bind_values)
+    if DataMapper::Cutie.tracking_query? query
+      query_start_time  = query_timers.delete(query.object_id)
+      query_end_time    = Time.now
+                                    
+      _call_info = caller[_calls_deep] || caller.last
+      _call_info = _call_info.split(':')
+     
+      DataMapper::Cutie.repo do
+        generalized_query  = GeneralizedQuery.find_or_make query, statement
+        DataMapper.logger.debug "BEGAN PROFILING ~ #{query.model} : #{generalized_query.operation}" 
+        executed_query = ExecutedQuery.new
+
+        executed_query.statement      = bind_statement(statement, bind_values)
+
+        executed_query.repo_signature = Digest::SHA1.hexdigest("#{query.repository.name}: #{executed_query.statement}")
+        executed_query.signature      = Digest::SHA1.hexdigest(executed_query.statement)
+
+        executed_query.elapsed_time   = BigDecimal.new(query_end_time.to_f.to_s) - BigDecimal.new(query_start_time.to_f.to_s)
+        executed_query.executed_at    = query_start_time
+
+        # Manhandle the data if its too big, should the fields just be blobs instead?
+        executed_query.caller_file    = _call_info[0][ -255, _call_info[0].length ] if _call_info[0]
+        executed_query.caller_line    = _call_info[1]
+        executed_query.caller_method  = _call_info[2][ 0, 255 ] if _call_info[2]
+
+        executed_query.bind_values    = bind_values
+        executed_query.generalized_query  = generalized_query
+        
+        executed_query.save
+        
+        DataMapper::Cutie.process_tracker_hooks(
+          query.repository.adapter.options[:adapter], # The current adapter
+          generalized_query.operation,                    # The current operation
+          executed_query                              # The currently executed query
+        )
+
+      end # Finish DataMapper::Cutie.repo context
+      
+    end #End if tracking_query?
+  end
+    
+end

data/lib/dm-cutie/tracker/data_objects/overrides.rb

@@ -0,0 +1,161 @@
+class DataMapper::Adapters::DataObjectsAdapter
+  def create(resources)
+    resources.each do |resource|
+      model      = resource.model
+      serial     = model.serial(name)
+      attributes = resource.dirty_attributes
+
+      properties  = []
+      bind_values = []
+
+      # make the order of the properties consistent
+      model.properties(name).each do |property|
+        next unless attributes.key?(property)
+
+        bind_value = attributes[property]
+
+        # skip insering NULL for columns that are serial or without a default
+        next if bind_value.nil? && (property.serial? || !property.default?)
+
+        # if serial is being set explicitly, do not set it again
+        if property.equal?(serial)
+          serial = nil
+        end
+
+        properties  << property
+        bind_values << bind_value
+      end
+
+      statement = insert_statement(model, properties, serial) 
+      
+      #### BEGIN DataMapper::Cutie ####  
+      # @note: Need a Query object for the tracker or to rewrite what the tracker takes, it was easier to just
+      #   make a BS Query object to pass in since the other CRUD methods have a query object.
+      query = DataMapper::Query.new(resource.repository, resource.model)
+      
+      start_tracking_timer(query) 
+
+      result    = execute(statement, *bind_values)                                        
+
+      #### END DataMapper::Cutie ####
+      track_query(query, statement, bind_values)
+      
+      if result.to_i == 1 && serial
+        serial.set!(resource, result.insert_id)
+      end
+    end
+  end
+
+  # Constructs and executes SELECT query, then instantiates
+  # one or many object from result set.
+  #
+  # @param [Query] query
+  #   composition of the query to perform
+  #
+  # @return [Array]
+  #   result set of the query
+  #
+  # @api semipublic
+  def read(query)
+    fields = query.fields
+    types  = fields.map { |property| property.primitive }
+
+    statement, bind_values = select_statement(query)
+
+    records = []
+
+    with_connection do |connection|
+      command = connection.create_command(statement)
+      command.set_types(types)
+
+      #### BEGIN DataMapper::Cutie ####
+      start_tracking_timer(query)
+      
+      reader = command.execute_reader(*bind_values)
+
+      track_query(query, statement, bind_values)
+      #### END DataMapper::Cutie ####
+
+      begin
+        while reader.next!
+          records << fields.zip(reader.values).to_hash
+        end
+      ensure
+        reader.close
+      end
+    end
+
+    records
+  end
+
+  # Constructs and executes UPDATE statement for given
+  # attributes and a query
+  #
+  # @param [Hash(Property => Object)] attributes
+  #   hash of attribute values to set, keyed by Property
+  # @param [Collection] collection
+  #   collection of records to be updated
+  #
+  # @return [Integer]
+  #   the number of records updated
+  #
+  # @api semipublic
+  def update(attributes, collection)
+    query = collection.query
+
+    # TODO: if the query contains any links, a limit or an offset
+    # use a subselect to get the rows to be updated
+
+    properties  = []
+    bind_values = []
+
+    # make the order of the properties consistent
+    query.model.properties(name).each do |property|
+      next unless attributes.key?(property)
+      properties  << property
+      bind_values << attributes[property]
+    end
+
+    statement, conditions_bind_values = update_statement(properties, query)
+
+    bind_values.concat(conditions_bind_values)
+          
+    ####  BEGIN DataMapper::Cutie ####
+    start_tracking_timer(query)
+    
+    result = execute(statement, *bind_values).to_i
+    
+    ####  END DataMapper::Cutie ####
+    track_query(query, statement, bind_values)  
+    
+    result
+  end
+
+  # Constructs and executes DELETE statement for given query
+  #
+  # @param [Collection] collection
+  #   collection of records to be deleted
+  #
+  # @return [Integer]
+  #   the number of records deleted
+  #
+  # @api semipublic
+  def delete(collection)
+    query = collection.query
+
+    # TODO: if the query contains any links, a limit or an offset
+    # use a subselect to get the rows to be deleted
+
+    statement, bind_values = delete_statement(query)
+    
+    ####  BEGIN DataMapper::Cutie ####
+    start_tracking_timer(query)
+    
+    result = execute(statement, *bind_values).to_i
+    
+    ####  END DataMapper::Cutie ####
+    track_query(query, statement, bind_values)  
+    
+    result
+  end
+end

data/lib/dm-cutie/tracker/hook/abstract.rb

@@ -0,0 +1,57 @@
+module DataMapper
+  module Cutie
+    module Tracker
+      module Hook
+        module Abstract
+          def self.included(model)
+            model.extend DataMapper::Cutie::Tracker::Hook::Abstract::ClassMethods
+          end
+  
+          module ClassMethods
+            # - supported_statements - Statements supported by this tracker hook
+            #
+            # @example
+            #   [:delete]
+            #
+            # @return [Array[Symbol]]
+            #
+            def supported_statements
+              [:select, :insert, :update, :delete]
+            end
+            
+            # - supported_adapters - List of adapters that will use this hook
+            #
+            # @example
+            #   [ :mysql, :sqlite3 ]
+            #
+            # @return [Array[Symbol]]
+            #
+            def supported_adapters
+              raise Exception, "#{self.class}.supported_adapters was not implemented"
+            end
+            
+            # - track - Factory method that is called to start your hook
+            #
+            # @param executed_query [ExecutedQuery] - the executed query
+            #
+            # return [NilClass]
+            #
+            def track( executed_query )
+              raise Exception, "#{self.class}.track was not implemented"
+            end
+    
+            # - hook_name - The name of your hook
+            #
+            # @return [String]
+            #
+            def hook_name
+              raise Exception, "#{self.class}.hook_name was not implemented"
+            end
+          end
+  
+          module InstanceMethods;end;  
+        end
+      end
+    end
+  end
+end

data/lib/dm-cutie/version.rb

@@ -0,0 +1,5 @@
+module DataMapper
+  module Cutie
+    VERSION = '0.3.16'.freeze
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: dm-cutie
+version: !ruby/object:Gem::Version 
+  version: 0.3.16
+platform: ruby
+authors: 
+- Cory ODaniel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-15 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: extlib
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.12
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: dm-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.10.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: dm-types
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.10.0
+    version: 
+description: DataMapper's Query Tracker; She is super thorough and easy as hell, just the way you like it.
+email: cutie@coryodaniel.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+- LICENSE
+- History.txt
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- lib/dm-cutie.rb
+- lib/dm-cutie/cutie.rb
+- lib/dm-cutie/version.rb
+- lib/dm-cutie/models/executed_query.rb
+- lib/dm-cutie/models/query_storage_link.rb
+- lib/dm-cutie/models/repository_storage.rb
+- lib/dm-cutie/models/generalized_query.rb
+- lib/dm-cutie/tracker/data_objects.rb
+- lib/dm-cutie/tracker/data_objects/helper.rb
+- lib/dm-cutie/tracker/data_objects/overrides.rb
+- lib/dm-cutie/tracker/hook/abstract.rb
+- History.txt
+has_rdoc: true
+homepage: http://github.com/coryodaniel/dm-cutie
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: DataMapper's Original Query Tracker'
+test_files: []
+