dm-cutie-extras 0.0.3

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2009, Cory ODaniel 
+
+Permission is hereby granted, free of charge, to any person obtaining a 
+copy of this software and associated documentation files (the "Software"), 
+to deal in the Software without restriction, including without limitation 
+the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+and/or sell copies of the Software, and to permit persons to whom the 
+Software is furnished to do so, subject to the following conditions: 
+
+The above copyright notice and this permission notice shall be included in 
+all copies or substantial portions of the Software. 
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL 
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
+DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,62 @@
+Description
+=============
+dm-cutie-extras is a pack of extra stuff for dm-cutie and dm-cutie-ui.
+
+
+Usage
+============
+    require 'dm-core'
+    require 'dm-cutie'
+    require 'dm-cutie-extras'
+    
+    DataMapper::Cutie::Extras.load :mysql_query_plan
+    
+    DataMapper::Cutie.start(true)
+
+
+Creating Views
+==============
+If your hook includes a DataMapper model and you are writing a view, the view name should
+be the plural of your model name
+
+
+Writing Tracker Hooks
+=====================
+See documentation @ http://github.com/coryodaniel/dm-cutie/
+
+
+Adding Custom Columns to Views
+==============================
+  The partial 'grid' takes three keys to create its local variables: :columns, :records, :adhoc_columns (discussed next)
+  
+  Columns should be respond to #each, it will generally be a DataMapper PropertySet. Each element in columns will be used in a #send method call on each of the elements in records. That means instead of doing the standard
+      partial :grid, :locals => { :columns => MyModel.properties, :records => @my_collection}
+      
+  You can add any other columns you want as long as there is a method that a 'record' will respond to. For example, every object has a 'class' method, so you could do
+      partial :grid, 
+        :locals => { 
+          :columns => MyModel.properties.to_a + [:class],
+          :records => @my_collection
+        }
+  
+  This would cause the class name to be output in a column (pretty useless), but you can add any method you want to the class and simply add its name to the set of elements being passed to :columns
+  
+  
+  As an alternative method you can pass a column name to a proc in the :adhoc_columns parameter
+    partial :grid,
+      :locals => {
+        :columns => MyModel.properties,
+        :records => @my_collection,
+        :adhoc_columns => {
+          :my_cool_class_name => lambda{|my_record| my_record.class }
+        }
+      }
+      
+  This would result in a column named 'my_cool_class_name' with a value of 'MyModel'. Obviously you can be more creative :)
+  
+  Note: the proc should accept one parameter, the specific record from the collection of items passed to :records
+  
+  IMPORTANT NOTE:
+    Remember, if you are adding additional columns to the grid, make sure you pass the column names to the 'menu' partial if you want the ability to hide that column.
+
+

data/Rakefile

@@ -0,0 +1,94 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require "extlib"
+
+require 'rake'
+require 'rake/clean'
+require 'spec/rake/spectask'
+require "spec"
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+ROOT    = Pathname(__FILE__).dirname.expand_path
+require ROOT + 'lib/dm-cutie-extras/version'
+
+@spec = Gem::Specification.new do |s|
+  s.name = %q{dm-cutie-extras}
+  s.version = DataMapper::Cutie::Extras::VERSION
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors     = ["Cory ODaniel"]
+  s.date        = %q{2009-10-15}
+  s.summary     = %q{DM Cutie's Extras}
+  s.description = %q{Cool additional hooks for DM Cutie.}
+
+  s.email = %q{cutie@coryodaniel.com}
+  
+  s.extra_rdoc_files = ["README.markdown", "LICENSE", "History.txt", "TODO.markdown"]
+  s.files = ["LICENSE", "README.markdown", "Rakefile", "TODO.markdown",
+    "lib/dm-cutie-extras.rb",
+    "lib/dm-cutie-extras/version.rb",       
+  ]
+  s.files += Dir[ "lib/dm-cutie-extras/views/*"]
+  s.files += Dir[ "lib/dm-cutie-extras/hooks/*"]
+
+  s.add_dependency "extlib",">=0.9.12"   
+  s.add_dependency "dm-core",  '>=0.10.0'
+  s.add_dependency "dm-types",  '>=0.10.0'
+
+  s.has_rdoc = true
+  s.homepage = "http://github.com/coryodaniel/dm-cutie-extras"
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.2.0}
+end
+
+[ ROOT, ROOT.parent ].each do |dir|
+  Pathname.glob(dir.join('tasks/**/*.rb').to_s).each { |f| require f }
+end
+
+NAME = @spec.name
+GEM_VERSION = DataMapper::Cutie::Extras::VERSION
+
+Rake::GemPackageTask.new(@spec) do |pkg|
+  pkg.gem_spec = @spec
+end
+
+desc "install the plugin locally"
+task :install => [:package] do
+  sh %{sudo gem install #{install_home} pkg/#{NAME}-#{GEM_VERSION} --no-update-sources}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{NAME}.gemspec", "w") do |file|
+    file.puts @spec.to_ruby
+  end
+end
+
+Rake::RDocTask.new do |rdoc|
+  files = ["README.markdown", "History.txt", "LICENSE", "lib/**/*.rb"]
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README.markdown"
+  rdoc.title = "DM Cutie Extras"
+
+  rdoc.rdoc_dir = "doc/rdoc"
+  rdoc.options << "--line-numbers" << "--inline-source"
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = Dir["./spec/**/*_spec.rb"]
+  t.spec_files.unshift './spec/spec_helper.rb'
+  
+  t.libs = ['lib']
+  t.spec_opts << "--color" << "--format" << "specdoc" #"progress"
+  
+  if ENV['RCOV']
+    t.rcov = true
+    t.rcov_opts << '--exclude' << 'pkg,spec,interactive.rb,install_test_suite.rb,lib/gems,' + Gem.path.join(',')
+    t.rcov_opts << '--text-summary'
+    t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+    t.rcov_opts << '--only-uncovered'
+  end
+end

data/TODO.markdown

@@ -0,0 +1,60 @@
+MysqlIndex
+=============
+  * Percent of times used (Need a way to set dependencies between hooks)
+    * mysql_index count times used queryplan.keys.split(',').member? index.key_name
+    * mysql_index count times used queryplan.possible_keys_.split(',').member? index.key_name
+
+  * link MysqlIndex to executed OR generalized query ?
+  * Offer DROP INDEX on mysql_index
+  * redundant index detection http://www.paragon-cs.com/presentations/querytuning.pdf
+
+
+MysqlOptimizations (Probably highly correlated to MysqlExecutionStep...)
+===================
+  * Offer ADD INDEX on generalized_query (Optimize Queries like this)
+  
+
+Amazon SimpleDB
+===============
+  * Cost calculation
+  
+
+MysqlExecutionStep
+==================
+  * full table scans causes:
+    * no WHERE clause 
+    * no index on any field in WHERE clause 
+    * poor selectivity on an indexed field 
+    * too many records meet WHERE conditions 
+    * MySQL version less than 5.0 and using OR in a WHERE clause 
+    * using SELECT * FROM
+  * select_type optimizers
+    * if MysqlExecutionStep.select_type =~ /DEPENDENT/i # Correlated subquery, consider rewriting as join
+  * type optimizers
+  * extra optimizers
+    * distinct
+    * full scan on NULL key
+    * Impossible WHERE noticed after reading const table
+    * No tables
+    * Not exists
+    * Range checked for each record (index map: N)
+    * Select tables optimized away
+    * Using filesort
+    * Using index
+    * Using index for group-by
+    * Using sort_union(...), Using union(...), Using intersect(...)
+    * Using temporary
+    * Using where
+    * Using where with pushed condition
+  * covering index useful
+    * When you have large tables 
+    * When you have long rows (BLOBS for example) 
+    * When extra columns do not increase key length  significantly 
+    * When you have a large join with a number of secondary table lookups 
+    * When a lot of rows match the same key value
+
+Analyze joins
+=============
+  * Repository Storage 'strongest' relationships (storage that a given storage is most frequently joined with)
+  * Repository Storage 'weakest' relationship
+  * Repository Storage w/ no relationship

data/lib/dm-cutie-extras.rb

@@ -0,0 +1,28 @@
+module DataMapper
+  module Cutie  
+    class Extras
+      class << self
+      
+        def view_path
+          @_view_paths ||={}
+        end
+      
+        def root
+          @_root_path ||= File.expand_path(File.dirname(__FILE__)) / 'dm-cutie-extras'
+        end
+      
+        def load(*_hooks)
+          _hooks.each do |_hook|
+            require DataMapper::Cutie::Extras.root / 'hooks' / _hook
+            hook_view_path = DataMapper::Cutie::Extras.root / 'views' / "#{_hook.to_s.pluralize}.erb"
+              
+            if File.exist? hook_view_path
+              DataMapper::Cutie::Extras.view_path[_hook] = hook_view_path
+            end
+          end
+        end
+      
+      end
+    end
+  end
+end

data/lib/dm-cutie-extras/hooks/mysql_execution_step.rb

@@ -0,0 +1,63 @@
+# Tracker Hook for recording mysql query plans
+#
+class MysqlExecutionStep
+  include DataMapper::Cutie::Tracker::Hook::Abstract
+  include DataMapper::Resource
+  
+  STATEMENT = "EXPLAIN EXTENDED %s"
+    
+  belongs_to :executed_query
+  property :id, Serial
+  
+  property :order,        Integer, :nullable => false #the order the step was executed in
+  property :type,         String
+  property :select_type,  String
+  property :table,        String #denormalized, duplicate, you can get this through self.generalized_query.query_storage_links.first(:primary_storage => true).repository_storage.table_name
+  property :possible_keys,String
+  property :used_key,     String # maps to: OpenStruct#key
+  property :used_key_len, String # maps to: OpenStruct#key_len
+  property :ref,          String
+  property :rows,         Integer
+  property :filtered,     Float 
+  property :extra,        String
+
+  def self.hook_name;            "MySQL Execution Steps"  end;
+  def self.supported_statements; [:select];          end;
+  def self.supported_adapters;   [:mysql];           end;
+  
+  def self.execute(target_repo, query_str)
+    repository(target_repo.to_sym).adapter.query MysqlExecutionStep::STATEMENT % query_str
+  end
+  
+  def self.track( executed_query )
+    # Perform the EXPLAIN against the original target repo  
+    raw_query_plan = MysqlExecutionStep.execute( 
+      executed_query.generalized_query.primary_storage.repo_name,
+      executed_query.statement 
+    )
+
+    #Store the MysqlExecutionSteps in the DM Cutie repo
+    DataMapper::Cutie.repo do
+      raw_query_plan.each_with_index do |raw_query_step, idx| 
+        attribs = raw_query_step.attributes
+        attribs.delete(:id) #get rid of the rowID from MySQL
+        attribs[:used_key]      = attribs.delete(:key)
+        attribs[:used_key_len]  = attribs.delete(:key_len)
+        query_step = MysqlExecutionStep.new(attribs)
+        query_step.order = idx + 1
+        query_step.executed_query = executed_query
+
+        query_step.save
+      end
+    end
+  end #end track
+end
+
+# Let executed query know it just got some mysql_execution_steps
+ExecutedQuery.send :has, (1/0.to_f), :mysql_execution_steps
+
+# Let Cutie know she needs to treat this as an internal model
+DataMapper::Cutie.add_internal_model :mysql_execution_step
+
+# Let cutie know she has a new hook
+DataMapper::Cutie.add_tracker_hook :mysql_execution_step

data/lib/dm-cutie-extras/hooks/mysql_index.rb

@@ -0,0 +1,132 @@
+# This isn't a Tracker::Hook, its actually and After Create hook for RepositoryStorage and ExecutedQuery
+#
+# In calculating the selectivity, since the number of records can change, I do the average selectivity
+#   and the final selectivity (on stopping Dm Cutie)
+#
+class MysqlIndex
+  include DataMapper::Resource
+    
+  STATEMENT = "SHOW INDEX FROM %s"
+    
+  belongs_to :repository_storage
+  property :id, Serial
+  property :non_unique, Boolean 
+  property :key_name, String    
+  property :sequence_in_index, Integer  # maps to: OpenStruct#Seq_in_index
+  property :table, String               #denormalized, accessible through repository_storage
+  property :column_name, String 
+  property :collation, String 
+  property :cardinality, Integer
+  property :sub_part, Integer 
+  property :packed, String 
+  property :null, String 
+  property :index_type, String
+  
+  ######### SELECTIVITY #########
+  # The distinctness of the values in the column
+  property :distinct_count, Integer, :default => 0, :nullable => false
+    
+  # denormalized, this is the count of 'executed_queries' that are related to this index
+  #  @note there is no direction relationship (belongs_to/has) to executed_query in this model 
+  property :execution_count, Integer, :default => 0, :nullable => false 
+  
+  # methods for selectivity
+  #   selectivity is calculated by count(*) / count(distinct(COLUMN_NAME)) the closer to 1.0 
+  #   the better the index
+  def selectivity
+    ( distinct_count.to_f / self.repository_storage.record_count.to_f )
+  end
+
+  # Shortcut method to R:W of repo
+  def table_read_to_write_ratio
+    self.repository_storage.read_to_write_ratio
+  end
+  
+  # TODO Row length could be a useful addition to calculating this
+  # TODO Potential Uses vs Actual Uses could be a useful addition to calculating this
+  #
+  def usefulness
+    # Number of records, read to write ratio, selectivity
+    num_records = self.repository_storage.record_count
+    num_reads   = self.repository_storage.total_selects
+    num_writes  = self.repository_storage.total_inserts + 
+                    self.repository_storage.total_deletes + 
+                    self.repository_storage.total_updates 
+
+    records_processed = num_records * execution_count
+    total_operations  = (num_reads + num_writes).to_f
+    read_percentage   = (num_reads / total_operations)
+    # write_percentage  = (num_writes / total_operations)
+    return( 
+      (total_operations * read_percentage * selectivity) / total_operations
+    )
+  end
+
+  # detect duplicate indexes
+  def duplicate
+    MysqlIndex.all(
+      :id.not       => self.id,
+      :table        => self.table,
+      :index_type   => self.index_type,
+      :column_name  => self.column_name
+    ).count != 0
+  end
+
+  ######### CLASS METHODS #########
+  def self.execute( target_repo, storage_name )
+    repository(target_repo.to_sym).adapter.query MysqlIndex::STATEMENT % storage_name
+  end
+  
+  # Track the selectivity of an index
+  def self.process_executed_query( executed_query )
+    executing_repo = executed_query.generalized_query.primary_storage
+    
+    MysqlIndex.all(MysqlIndex.repository_storage.id => executing_repo.id).each do |mysql_index|
+      # Get to the repo BEING tracked for distinct count      
+      distinct_column_count = DataMapper.repository(executing_repo.repo_name.to_sym) do |exec_repo|
+        exec_repo.adapter.query(
+          "SELECT COUNT(DISTINCT(`#{mysql_index.column_name}`)) FROM `#{mysql_index.table}`"
+        ).first
+      end
+      
+      DataMapper::Transaction.new.link do
+        mysql_index.distinct_count = distinct_column_count
+        mysql_index.execution_count += 1
+        mysql_index.save
+      end
+    end
+  end
+  
+  
+        
+  # Track the indexes on a Repository Storage
+  def self.process_repository_storage( repository_storage )
+    # Perform the SHOW index on the repos storage
+    raw_index_list = MysqlIndex.execute( repository_storage.repo_name, repository_storage.storage_name )
+
+    #Store the MysqlIndex in the DM Cutie repo
+    DataMapper::Cutie.repo do
+      raw_index_list.each_with_index do |shown_index, idx| 
+        attribs = shown_index.attributes
+        attribs.delete(:comment)
+        attribs[:sequence_in_index]      = attribs.delete(:seq_in_index)
+        mysql_index = MysqlIndex.new(attribs)
+        mysql_index.repository_storage = repository_storage
+
+        mysql_index.save
+      end
+    end
+  end #end process_repository_storage
+        
+end
+
+# Let executed query know it just got some mysql_execution_steps
+RepositoryStorage.send :has, (1/0.to_f), :mysql_indexes
+
+# Let Cutie know she needs to treat this as an internal model
+DataMapper::Cutie.add_internal_model :mysql_index
+
+# Add this to the after(:create) for RepositoryStorage
+RepositoryStorage.send(:after,:create){ MysqlIndex.process_repository_storage self }
+
+ExecutedQuery.send(:after, :create){ MysqlIndex.process_executed_query self }

data/lib/dm-cutie-extras/hooks/mysql_warning.rb

@@ -0,0 +1,48 @@
+# Tracker Hook for recording mysql warnings
+#
+class MysqlWarning
+  include DataMapper::Cutie::Tracker::Hook::Abstract
+  include DataMapper::Resource
+    
+  STATEMENT = "SHOW WARNINGS"
+    
+  belongs_to :executed_query
+  property :id, Serial
+  
+  property :level, String
+  property :code, Integer
+  property :message, Text
+
+  def self.hook_name;            "MySQL Warnings"  end;
+  def self.supported_statements; [:select, :insert, :update, :delete]; end;
+  def self.supported_adapters;   [:mysql];           end;
+  
+  def self.track( executed_query )
+    # Perform the show warings
+    raw_warnings = repository(
+      executed_query.generalized_query.primary_storage.repo_name.to_sym
+    ).adapter.query MysqlWarning::STATEMENT % executed_query.statement
+
+    #Store the MysqlWarning in the DM Cutie repo
+    DataMapper::Cutie.repo do
+      raw_warnings.each_with_index do |raw_warning, idx| 
+        next if raw_warning.attributes[:level] =~ /^note$/i
+        attribs = raw_warning.attributes
+        mysql_warning = MysqlWarning.new(attribs)
+        mysql_warning.executed_query = executed_query
+        mysql_warning.save
+      end
+    end
+  end #end track
+
+
+end
+
+# Let executed query know it just got some mysql_warnings
+ExecutedQuery.send :has, (1/0.to_f), :mysql_warnings
+
+# Let Cutie know she needs to treat this as an internal model
+DataMapper::Cutie.add_internal_model :mysql_warning
+
+# Let cutie know she has a new hook
+DataMapper::Cutie.add_tracker_hook :mysql_warning

data/lib/dm-cutie-extras/hooks/sqlite3_execution_step.rb

@@ -0,0 +1,55 @@
+# Tracker Hook for recording sqlite3 query plans
+#
+class Sqlite3ExecutionStep
+  include DataMapper::Cutie::Tracker::Hook::Abstract
+  include DataMapper::Resource
+  
+  STATEMENT = "EXPLAIN QUERY PLAN %s"
+    
+  belongs_to :executed_query
+  property :id, Serial
+  
+  property :order,        Integer, :nullable => false #the order the step was executed in
+  property :from,         Integer, :nullable => false #the table the step was performed against
+  property :detail,       Text # "TABLE people WITH INDEX index_people_person_name_idx"
+
+  def self.hook_name
+    "Sqlite3 Execution Steps"
+  end
+  def self.supported_statements
+    [:select, :insert, :update, :delete]
+  end
+  def self.supported_adapters
+    [:sqlite3]
+  end
+  
+  def self.track( executed_query )
+    # Perform the EXPLAIN against the original target repo      
+    raw_query_plan = repository(
+      executed_query.generalized_query.primary_storage.repo_name.to_sym
+    ).adapter.query Sqlite3ExecutionStep::STATEMENT % executed_query.statement
+
+    #Store the Sqlite3ExecutionStep in the DM Cutie repo
+    DataMapper::Cutie.repo do
+      raw_query_plan.each_with_index do |raw_query_step, idx|
+        attribs = raw_query_step.attributes       
+        query_step = Sqlite3ExecutionStep.new(attribs)
+        query_step.order  = attribs[:order]
+        query_step.from   = attribs[:from]
+        query_step.detail = attribs[:detail]
+        query_step.executed_query = executed_query
+        query_step.save
+      end
+    end
+  end
+
+end
+
+# Tell executed query it has sqlite3 execution steps
+ExecutedQuery.send :has, (1/0.to_f), :sqlite3_execution_steps
+
+# Let Cutie know she needs to treat this as an internal model
+DataMapper::Cutie.add_internal_model :sqlite3_execution_step
+
+# Let cutie know she has a new hook 
+DataMapper::Cutie.add_tracker_hook :sqlite3_execution_step

data/lib/dm-cutie-extras/version.rb

@@ -0,0 +1,7 @@
+module DataMapper
+  module Cutie
+    module Extras
+      VERSION = '0.0.3'.freeze
+    end
+  end
+end

data/lib/dm-cutie-extras/views/_template_.erb

@@ -0,0 +1,47 @@
+<% 
+  # This should be an array of DM Properties or symbols, essentially things
+  #   that can be 'sent' to each of your records
+  #   @my_record.send(_element_in_columns_array_)
+  
+  @columns = YOUR_MODEL.properties
+%>
+
+<%= partial :menu, :locals => {:columns => @columns} %>
+
+<%
+  query = {}
+  
+  # @example: ExecutedQuery.generalized_query.query_storage_links.repository_storage
+  # @note: Yours will likeley by YOUR_MODEL.executed_query.generalized_query.query_storage_links.repository_storage
+  # 
+  # The point in this is that DM CutieUI allows you to filter result sets by Repository, Adapter and Model
+  #   This builds the join statement for narrowing that down.  You just have to set up how to find the relationshps
+  #   between this model and the RepositoryStorage model
+  relationship_path_to_repo_storage_model = YOUR_MODEL.relationship.path.to.repository_storage
+  
+  unless ram_filters[:repository].blank?
+    query[relationship_path_to_repo_storage_model.repo_name]= ram_filters[:repository]  
+  end
+
+  unless ram_filters[:adapter].blank?
+    query[relationship_path_to_repo_storage_model.adapter_name]= ram_filters[:adapter]  
+  end
+
+  unless ram_filters[:model].blank?
+    query[relationship_path_to_repo_storage_model.model_name]= ram_filters[:model]  
+  end
+
+  # Additionally parameters may come in with specific values to filter from the result set
+  # query = parse_params(YOUR_MODEL).merge(query)
+
+  @records = YOUR_MODEL.all(query)
+%>
+
+<%= partial :grid, 
+  :locals => {
+    :columns => @columns, 
+    :records => @records,
+    :adhoc_columns => {},
+    :relationships => YOUR_MODEL.relationships
+  }
+%>

data/lib/dm-cutie-extras/views/mysql_execution_steps.erb

@@ -0,0 +1,71 @@
+<% help_link %>
+<% @columns = MysqlExecutionStep.properties %>
+<%= partial :menu, :locals => {:columns => @columns } %>
+
+<%
+  query = {}
+  path_to_repo_storage = MysqlExecutionStep.executed_query.generalized_query.query_storage_links.repository_storage
+  unless ram_filters[:repository].blank?
+    query[path_to_repo_storage.repo_name]= ram_filters[:repository]  
+  end
+
+  unless ram_filters[:adapter].blank?
+    query[path_to_repo_storage.adapter_name]= ram_filters[:adapter]  
+  end
+
+  unless ram_filters[:model].blank?
+    query[path_to_repo_storage.model_name]= ram_filters[:model]  
+  end
+
+  query = parse_params(MysqlExecutionStep).merge(query)
+  @records = MysqlExecutionStep.all(query)
+%>
+
+<%= partial :grid, 
+  :locals => {
+    :columns => @columns, 
+    :records => @records,
+    :relationships => MysqlExecutionStep.relationships
+  }
+%>
+
+<a name="help">
+  <div class="help_container">
+    <p>
+      <a href="http://dev.mysql.com/doc/refman/5.0/en/using-explain.html">
+        Details on MySQL's explain statement can be read up on here.
+      </a>
+    </p>
+    <p>
+      Below is a list of column explanations
+      <ul>
+        <li>select_type - type of SELECT</li>
+        <li>table - the name of the table or alias</li>
+        <li>type - the type of join used for the query</li>
+        <li>possible_keys - indexes MySQL could possible use</li>
+        <li>used_key - indexes MySQL actually used</li>
+        <li>used_key_len - the total length of keys used</li>
+        <li>ref - any columns used with key to retrieve results</li>
+        <li>rows - estimated number of rows returned</li>
+        <li>extra - additional details</li>
+      </ul>
+      
+      Below is a list of the MySQL Execution Plan step 'types'. They are listed in order from best to worst.
+      <ul>
+        <li>system</li>
+        <li>const</li>
+        <li>eq_ref</li>
+        <li>ref</li>
+        <li>fulltext</li>
+        <li>ref_or_null</li>
+        <li>index_merge</li>
+        <li>unique_subquery</li>
+        <li>index_subquery</li>
+        <li>range</li>
+        <li>index</li>
+        <li>all</li>
+      </ul>
+    </p>
+  
+  </div>
+</a>

data/lib/dm-cutie-extras/views/mysql_indexes.erb

@@ -0,0 +1,45 @@
+<% @columns = MysqlIndex.properties.to_a + [:usefulness, :selectivity, :table_read_to_write_ratio, :usefulness, :duplicate] %>
+
+<%= partial :menu, :locals => {:columns => @columns} %>
+
+<%
+  query = {}
+    
+  unless ram_filters[:repository].blank?
+    query[MysqlIndex.repository_storage.repo_name]= ram_filters[:repository]  
+  end
+
+  unless ram_filters[:adapter].blank?
+    query[MysqlIndex.repository_storage.adapter_name]= ram_filters[:adapter]  
+  end
+
+  unless ram_filters[:model].blank?
+    query[MysqlIndex.repository_storage.model_name]= ram_filters[:model]  
+  end
+  query = parse_params(MysqlIndex).merge(query)
+  @records = MysqlIndex.all(query)
+%>
+
+<%= partial :grid, 
+  :locals => {
+    :columns => @columns, 
+    :records => @records,
+    :adhoc_columns => {},
+    :relationships => MysqlIndex.relationships
+  }
+%>
+
+<a name="help">
+  <div class="help_container">
+    <p>
+      <em>Selectivity</em> measures the selectiveness of an index. The closer to '1' the better, the closer it is to '0' the MySQL optimizer will probably not use it.
+      Unused indexes should be dropped because they still slow down write performance.
+    </p>
+    <p>
+      <em>Duplicate</em> determines whether a duplicate (same index_type) index is on the table/column. Duplicate indexes require <em>n</em> times the index management, and should be avoided
+    </p>
+    <p>
+      <em>Usefulness</em> is just a weight to compare indexes on the same table to determine how useful an index may be. This calculation will change over time as this mysql_index plugin gets more refined. From 0 to 1, the closer to 1 the better.
+    </p>
+  </div>
+</a>

data/lib/dm-cutie-extras/views/mysql_warnings.erb

@@ -0,0 +1,35 @@
+<%   
+  @columns = MysqlWarning.properties
+%>
+
+<%= partial :menu, :locals => {:columns => @columns} %>
+
+<%
+  query = {}
+
+  relationship_path_to_repo_storage_model = MysqlWarning.executed_query.generalized_query.query_storage_links.repository_storage
+  
+  unless ram_filters[:repository].blank?
+    query[relationship_path_to_repo_storage_model.repo_name]= ram_filters[:repository]  
+  end
+
+  unless ram_filters[:adapter].blank?
+    query[relationship_path_to_repo_storage_model.adapter_name]= ram_filters[:adapter]  
+  end
+
+  unless ram_filters[:model].blank?
+    query[relationship_path_to_repo_storage_model.model_name]= ram_filters[:model]  
+  end
+  
+  query = parse_params(MysqlWarning).merge(query)
+  @records = MysqlWarning.all(query)
+%>
+
+<%= partial :grid, 
+  :locals => {
+    :columns => @columns, 
+    :records => @records,
+    :adhoc_columns => {},
+    :relationships => MysqlWarning.relationships
+  }
+%>

data/lib/dm-cutie-extras/views/sqlite3_execution_steps.erb

@@ -0,0 +1,29 @@
+<% @columns = Sqlite3ExecutionStep.properties %>
+<%= partial :menu, :locals => {:columns => @columns} %>
+
+<%
+  query = {}
+  path_to_repo_storage = Sqlite3ExecutionStep.executed_query.generalized_query.query_storage_links.repository_storage
+  unless ram_filters[:repository].blank?
+    query[path_to_repo_storage.repo_name]= ram_filters[:repository]  
+  end
+
+  unless ram_filters[:adapter].blank?
+    query[path_to_repo_storage.adapter_name]= ram_filters[:adapter]  
+  end
+
+  unless ram_filters[:model].blank?
+    query[path_to_repo_storage.model_name]= ram_filters[:model]  
+  end
+
+  query = parse_params(Sqlite3ExecutionStep).merge(query)
+  @records = Sqlite3ExecutionStep.all(query)
+%>
+
+<%= partial :grid, 
+  :locals => {
+    :columns => @columns, 
+    :records => @records,
+    :relationships => Sqlite3ExecutionStep.relationships
+  }
+%>

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: dm-cutie-extras
+version: !ruby/object:Gem::Version 
+  version: 0.0.3
+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: Cool additional hooks for DM Cutie.
+email: cutie@coryodaniel.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+- LICENSE
+- History.txt
+- TODO.markdown
+files: 
+- LICENSE
+- README.markdown
+- Rakefile
+- TODO.markdown
+- lib/dm-cutie-extras.rb
+- lib/dm-cutie-extras/version.rb
+- History.txt
+- lib/dm-cutie-extras/views/_template_.erb
+- lib/dm-cutie-extras/views/mysql_execution_steps.erb
+- lib/dm-cutie-extras/views/mysql_indexes.erb
+- lib/dm-cutie-extras/views/mysql_warnings.erb
+- lib/dm-cutie-extras/views/sqlite3_execution_steps.erb
+- lib/dm-cutie-extras/hooks/mysql_execution_step.rb
+- lib/dm-cutie-extras/hooks/mysql_index.rb
+- lib/dm-cutie-extras/hooks/mysql_warning.rb
+- lib/dm-cutie-extras/hooks/sqlite3_execution_step.rb
+has_rdoc: true
+homepage: http://github.com/coryodaniel/dm-cutie-extras
+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: DM Cutie's Extras
+test_files: []
+