appstats 0.15.1 → 0.16.1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    appstats (0.15.1)
+    appstats (0.16.1)
       daemons
       net-scp
       rails (>= 2.3.0)

data/db/migrations/20110301212017_add_appstats_results_query_type.rb

@@ -0,0 +1,11 @@
+class AddAppstatsResultsQueryType < ActiveRecord::Migration
+  def self.up
+    add_column :appstats_results, :query_type, :string
+    add_column :appstats_result_jobs, :query_type, :string
+  end
+
+  def self.down
+    remove_column :appstats_results, :query_type
+    remove_column :appstats_result_jobs, :query_type
+  end
+end

data/db/migrations/20110301230757_rename_appstats_results_query_as_sql_to_query_to_sql.rb

@@ -0,0 +1,9 @@
+class RenameAppstatsResultsQueryAsSqlToQueryToSql < ActiveRecord::Migration
+  def self.up
+    rename_column :appstats_results, :query_as_sql, :query_to_sql
+  end
+
+  def self.down
+    rename_column :appstats_results, :query_to_sql, :query_as_sql
+  end
+end

data/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended to check this file into your version control system.
 
-ActiveRecord::Schema.define(:version => 20110301195959) do
+ActiveRecord::Schema.define(:version => 20110301230757) do
 
   create_table "appstats_actions", :force => true do |t|
     t.string   "name"
@@ -102,13 +102,14 @@ ActiveRecord::Schema.define(:version => 20110301195959) do
     t.datetime "last_run_at"
     t.datetime "created_at"
     t.datetime "updated_at"
+    t.string   "query_type"
   end
 
   create_table "appstats_results", :force => true do |t|
     t.string   "name"
     t.string   "result_type"
     t.text     "query"
-    t.text     "query_as_sql"
+    t.text     "query_to_sql"
     t.integer  "count"
     t.string   "action"
     t.string   "host"
@@ -120,6 +121,7 @@ ActiveRecord::Schema.define(:version => 20110301195959) do
     t.text     "contexts"
     t.text     "group_query_to_sql"
     t.string   "group_by"
+    t.string   "query_type"
   end
 
   add_index "appstats_results", ["action"], :name => "index_appstats_results_on_action"

data/lib/appstats.rb

@@ -19,6 +19,7 @@ require "#{File.dirname(__FILE__)}/appstats/host"
 require "#{File.dirname(__FILE__)}/appstats/context_key"
 require "#{File.dirname(__FILE__)}/appstats/context_value"
 require "#{File.dirname(__FILE__)}/appstats/test_object"
+require "#{File.dirname(__FILE__)}/appstats/test_query"
 
 # required in the appstats.gemspec
 unless Appstats.const_defined?(:VERSION)

data/lib/appstats/query.rb

@@ -3,15 +3,16 @@ module Appstats
   class Query
 
     @@parser_template = Appstats::Parser.new(:rules => ":operation :action :date on :host where :contexts group by :group_by")
-    @@contexts_parser_template = Appstats::Parser.new(:rules => ":context", :repeating => true, :tokenize => "and or || && = <= >= <> != ( ) like")
+    @@contexts_parser_template = Appstats::Parser.new(:rules => ":context", :repeating => true, :tokenize => "and or || && = <= >= <> < > != ( ) like")
     @@group_by_parser_template = Appstats::Parser.new(:rules => ":filter", :repeating => true, :tokenize => ",")
 
     @@nill_query = "select 0 from appstats_entries LIMIT 1"
     @@default = "1=1"
-    attr_accessor :name, :query, :action, :host, :date_range, :query_to_sql, :contexts, :group_by, :group_query_to_sql
+    attr_accessor :name, :query, :action, :host, :date_range, :query_to_sql, :contexts, :parsed_contexts, :group_by, :group_query_to_sql, :query_type
 
     def initialize(data = {})
       @name = data[:name]
+      @query_type = data[:query_type]
       @result_type = data[:result_type] || "on_demand"
       self.query=(data[:query])
     end
@@ -19,20 +20,34 @@ module Appstats
     def query=(value)
       @query = value
       parse_query
+      
+      unless @query_type.nil?
+        
+        all_names = @query_type.split("::")
+        if all_names.size == 1
+          @custom_query = Object::const_get(@query_type).new  
+        else
+          @custom_query = eval(all_names[0...-1].join("::")).const_get(all_names.last).new
+        end
+        @custom_query.query = self
+        @custom_query.process_query
+      end
+      
     end
     
     def run
-      result = Appstats::Result.new(:name => @name, :result_type => @result_type, :query => @query, :query_as_sql => @query_to_sql, :action => @action, :host => @host, :from_date => @date_range.from_date, :to_date => @date_range.to_date, :contexts => @contexts)
+      result = Appstats::Result.new(:name => @name, :result_type => @result_type, :query => @query, :query_to_sql => @query_to_sql, :action => @action, :host => @host, :from_date => @date_range.from_date, :to_date => @date_range.to_date, :contexts => @contexts, :query_type => @query_type)
       unless @group_by.empty?
         result.group_by = @group_by.join(", ")
         result.group_query_to_sql = @group_query_to_sql
       end
+
       result.group_by = @group_by.join(", ") unless @group_by.empty?
-      result.count = ActiveRecord::Base.connection.select_one(@query_to_sql)["count(*)"].to_i
+      result.count = run_query { |conn| conn.select_one(@query_to_sql)["num"].to_i }
       result.save
-      
+
       unless @group_by.empty?
-        all_sub_results = ActiveRecord::Base.connection.select_all(@group_query_to_sql)
+        all_sub_results = run_query { |conn| conn.select_all(@group_query_to_sql) }
         all_sub_results.each do |data|
           keys = data["context_key_filter"].split(",")
           values = data["context_value_filter"].split(",")
@@ -57,32 +72,36 @@ module Appstats
       "EXISTS (select * from appstats_log_collectors where appstats_entries.appstats_log_collector_id = appstats_log_collectors.id and host = '#{host}' )"
     end
 
-    def self.contexts_filter_to_sql(raw_input)
+    def contexts_filter_to_sql
       context_parser = @@contexts_parser_template.dup
-      return @@default if (raw_input.blank? || !context_parser.parse(raw_input))
+      return @@default if @contexts.blank? || !context_parser.parse(@contexts)
       sql = "EXISTS (select * from appstats_contexts where appstats_entries.id = appstats_contexts.appstats_entry_id and ("
       
       status = :next
       comparator = "="
       context_parser.raw_results.each do |entry|
         if entry.kind_of?(String)
-          sqlentry = sqlize(entry)
+          sqlentry = Query.sqlize(entry)
           if Query.comparator?(entry) && status == :waiting_comparator
-            comparator = sqlize(entry)
+            comparator = Query.sqlize(entry)
             status = :waiting_operand
           else
             sql += ")" if status == :waiting_comparator
             sql += " #{sqlentry}"
+            @parsed_contexts<< sqlentry
             status = :next
           end
           next
         end
         if status == :next
           status = :waiting_comparator
-          sql += " (context_key = '#{sqlclean(entry[:context])}'"
+          @parsed_contexts<< { :context_key => entry[:context] }
+          sql += " (context_key = '#{Query.sqlclean(entry[:context])}'"
         else
           status = :next
-          sql += " and context_value #{comparator} '#{sqlclean(entry[:context])}')"
+          @parsed_contexts.last[:context_value] = entry[:context]
+          @parsed_contexts.last[:comparator] = comparator
+          sql += " and context_value #{comparator} '#{Query.sqlclean(entry[:context])}')"
         end
       end
       sql += ")" if status == :waiting_comparator
@@ -116,6 +135,25 @@ module Appstats
     
     private
     
+      def db_connection
+        return ActiveRecord::Base.connection if @custom_query.nil?
+        @backup_config = ActiveRecord::Base.connection.instance_variable_get(:@config)
+        custom_connection = @custom_query.db_connection
+      end
+    
+      def restore_connection
+        return if @backup_config.nil?
+        ActiveRecord::Base.establish_connection @backup_config
+        @backup_config = nil
+      end
+    
+      def run_query
+        results = yield db_connection
+        restore_connection
+        results
+      end
+    
+    
       def normalize_action_name(action_name)
         action = Appstats::Action.where("plural_name = ?",action_name).first
         action.nil? ? action_name : action.name 
@@ -130,6 +168,12 @@ module Appstats
         end
       end
       
+      def parse_contexts(raw_input)
+        @contexts = raw_input
+        context_parser = @@contexts_parser_template.dup
+        return if (raw_input.blank? || !context_parser.parse(raw_input))
+      end
+      
       def parse_query
         reset_query
         return nil_query if @query.nil?
@@ -142,21 +186,21 @@ module Appstats
         @action = normalize_action_name(parser.results[:action])
         @date_range = DateRange.parse(parser.results[:date])
         @host = parser.results[:host]
-        @contexts = parser.results[:contexts]
+        parse_contexts(parser.results[:contexts])
         parse_group_by(parser.results[:group_by])
         
         if @operation == "#"
-          @query_to_sql = "select count(*) from appstats_entries"
+          @query_to_sql = "select count(*) as num from appstats_entries"
           @query_to_sql += " where action = '#{@action}'" unless @action.blank?
           @query_to_sql += " and #{@date_range.to_sql}" unless @date_range.to_sql == "1=1"
           @query_to_sql += " and #{Query.host_filter_to_sql(@host)}" unless @host.nil?
-          @query_to_sql += " and #{Query.contexts_filter_to_sql(@contexts)}" unless @contexts.nil?
+          @query_to_sql += " and #{contexts_filter_to_sql}" unless @contexts.nil?
         end
 
         unless @group_by.empty?
-          query_to_sql_with_id = @query_to_sql.sub("count(*)","id")
+          query_to_sql_with_id = @query_to_sql.sub("count(*) as num","id")
           group_as_sql = @group_by.collect { |g| "'#{Query.sqlclean(g)}'" }.join(',')
-          @group_query_to_sql = "select context_key_filter, context_value_filter, count(*) num from (select group_concat(appstats_contexts.context_key) as context_key_filter, group_concat(appstats_contexts.context_value) as context_value_filter, appstats_entry_id from appstats_contexts where context_key in (#{group_as_sql}) and appstats_entry_id in ( #{query_to_sql_with_id} ) group by appstats_entry_id) results group by context_value_filter;"
+          @group_query_to_sql = "select context_key_filter, context_value_filter, count(*) as num from (select group_concat(appstats_contexts.context_key) as context_key_filter, group_concat(appstats_contexts.context_value) as context_value_filter, appstats_entry_id from appstats_contexts where context_key in (#{group_as_sql}) and appstats_entry_id in ( #{query_to_sql_with_id} ) group by appstats_entry_id) results group by context_value_filter"
         end
 
         @query_to_sql
@@ -183,6 +227,8 @@ module Appstats
         nil_query
         @date_range = DateRange.new
         @group_by = []
+        @contexts = nil
+        @parsed_contexts = []
       end
     
   end

data/lib/appstats/result.rb

@@ -2,7 +2,7 @@ module Appstats
   class Result < ActiveRecord::Base
     set_table_name "appstats_results"
 
-    attr_accessible :name, :result_type, :query, :query_as_sql, :count, :action, :host, :from_date, :to_date, :contexts, :group_by
+    attr_accessible :name, :result_type, :query, :query_to_sql, :count, :action, :host, :from_date, :to_date, :contexts, :group_by, :query_type
     has_many :sub_results, :table_name => 'appstats_subresults', :foreign_key => 'appstats_result_id', :order => 'count DESC'
 
     def date_to_s
@@ -47,7 +47,7 @@ module Appstats
     private
 
       def state
-        [name, result_type, query, query_as_sql, count, action, host, from_date, to_date,contexts,group_by]
+        [name, result_type, query, query_to_sql, count, action, host, from_date, to_date,contexts,group_by,query_type]
       end
 
     

data/lib/appstats/result_job.rb

@@ -2,7 +2,7 @@ module Appstats
   class ResultJob < ActiveRecord::Base
     set_table_name "appstats_result_jobs"
 
-    attr_accessible :name, :frequency, :status, :query, :last_run_at
+    attr_accessible :name, :frequency, :status, :query, :last_run_at, :query_type
 
     @@frequency_methods = 
 

data/lib/appstats/test_query.rb

@@ -0,0 +1,42 @@
+
+module Appstats
+  class TestQuery
+
+    attr_accessor :query, :query_to_sql, :group_query_to_sql
+
+    def process_query
+      query.query_to_sql = "select count(*) as num from appstats_test_objects"
+      query.group_query_to_sql = "select context_key_filter, context_value_filter, count(*) as num from (select 'name' as context_key_filter, name as context_value_filter from appstats_test_objects) results group by context_value_filter"
+    end
+    
+    def db_connection
+      if query.host == "otherServer"
+        dbconfig = YAML::load(File.open('db/config.yml'))
+        ActiveRecord::Base.establish_connection(dbconfig['development']).connection
+      else
+        ActiveRecord::Base.connection
+      end
+    end
+    
+  end
+  
+  module Core
+    class AnotherTestQuery
+      attr_accessor :query
+      def process_query; end
+      def db_connection
+        ActiveRecord::Base.connection
+      end
+
+    end
+  end
+  
+end
+
+class YetAnotherTestQuery
+  attr_accessor :query
+  def process_query; end
+  def db_connection
+    ActiveRecord::Base.connection
+  end
+end

data/lib/appstats/version.rb

@@ -1,3 +1,3 @@
 module Appstats
-  VERSION = "0.15.1"
+  VERSION = "0.16.1"
 end

data/spec/entry_spec.rb

@@ -193,18 +193,18 @@ module Appstats
       end
       
       it "should understand an entry without contexts" do
-        entry = Entry.create_from_logger_string("0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search")
+        entry = Entry.create_from_logger_string("0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search")
         Entry.count.should == @before_count + 1
         entry.action.should == "address_search"
-        entry.raw_entry.should == "0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search"
+        entry.raw_entry.should == "0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search"
         entry.occurred_at.should == Time.parse("2010-09-21 23:15:20")
       end
       
       it "should understand contexts" do
-        entry = Entry.create_from_logger_string("0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live")
+        entry = Entry.create_from_logger_string("0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live")
         Entry.count.should == @before_count + 1
         entry.action.should == "address_filter"
-        entry.raw_entry.should == "0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live"
+        entry.raw_entry.should == "0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live"
         entry.occurred_at.should == Time.parse("2010-09-21 23:15:20")
         entry.contexts.size.should == 2
         entry.contexts[0].context_key = "app_name"
@@ -214,10 +214,10 @@ module Appstats
       end
       
       it "should handle 'action' as a context" do
-        entry = Entry.create_from_logger_string('0.15.1 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : action=save_ovcen : app_name=cdb')
+        entry = Entry.create_from_logger_string('0.16.1 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : action=save_ovcen : app_name=cdb')
         Entry.count.should == @before_count + 1
         entry.action.should == "page-view"
-        entry.raw_entry.should == "0.15.1 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : action=save_ovcen : app_name=cdb"
+        entry.raw_entry.should == "0.16.1 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : action=save_ovcen : app_name=cdb"
         entry.occurred_at.should == Time.parse("2011-02-24 12:59:57")
         entry.contexts.size.should == 2
         entry.contexts[0].context_key = "action"
@@ -228,10 +228,10 @@ module Appstats
       end
       
       it "should handle multiple of the same 'context'" do
-        entry = Entry.create_from_logger_string('0.15.1 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : app_name=market : app_name=cdb')
+        entry = Entry.create_from_logger_string('0.16.1 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : app_name=market : app_name=cdb')
         Entry.count.should == @before_count + 1
         entry.action.should == "page-view"
-        entry.raw_entry.should == "0.15.1 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : app_name=market : app_name=cdb"
+        entry.raw_entry.should == "0.16.1 setup[:,=,-n] 2011-02-24 12:59:57 action=page-view : app_name=market : app_name=cdb"
         entry.occurred_at.should == Time.parse("2011-02-24 12:59:57")
         entry.contexts.size.should == 2
         entry.contexts[0].context_key = "app_name"

data/spec/logger_spec.rb

@@ -115,12 +115,12 @@ module Appstats
       
       it "should accept numbers" do
         Appstats::Logger.entry(5, :blah => 6)   
-        Appstats::Logger.raw_read.should == ["0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=5 : blah=6"]
+        Appstats::Logger.raw_read.should == ["0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=5 : blah=6"]
       end
 
       it "should accept arrays" do
         Appstats::Logger.entry('search', :provider => [ 'one', 'two' ])   
-        Appstats::Logger.raw_read.should == ["0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=search : provider=one : provider=two"]
+        Appstats::Logger.raw_read.should == ["0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=search : provider=one : provider=two"]
       end
 
 
@@ -130,7 +130,7 @@ module Appstats
 
       it "should look similar to regular entry" do
         Appstats::Logger.exception_entry(RuntimeError.new("blah"),:on => "login")   
-        Appstats::Logger.raw_read.should == ["0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=appstats-exception : error=blah : on=login"]
+        Appstats::Logger.raw_read.should == ["0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=appstats-exception : error=blah : on=login"]
       end
       
     end
@@ -147,47 +147,47 @@ module Appstats
     
        it "should handle a statistics entry" do
          expected = { :action => "address_search", :timestamp => "2010-09-21 23:15:20" }
-         actual = Appstats::Logger.entry_to_hash("0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search")
+         actual = Appstats::Logger.entry_to_hash("0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search")
          actual.should == expected
        end
        
        it "should handle contexts" do
          expected = { :action => "address_filter", :timestamp => "2010-09-21 23:15:20", :server => "Live", :app_name => 'Market' }
-         actual = Appstats::Logger.entry_to_hash("0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live")
+         actual = Appstats::Logger.entry_to_hash("0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live")
          actual.should == expected
        end
 
        it "should handle multiple actions" do
          expected = { :action => ["address_filter", "blah"], :timestamp => "2010-09-21 23:15:20", :server => "Live", :app_name => 'Market' }
-         actual = Appstats::Logger.entry_to_hash("0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : action=blah : app_name=Market : server=Live")
+         actual = Appstats::Logger.entry_to_hash("0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : action=blah : app_name=Market : server=Live")
          actual.should == expected
        end
 
        it "should handle multiple of same context" do
          expected = { :action => "address_filter", :timestamp => "2010-09-21 23:15:20", :server => "Live", :app_name => ['Sin','Market'] }
-         actual = Appstats::Logger.entry_to_hash("0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Sin : app_name=Market : server=Live")
+         actual = Appstats::Logger.entry_to_hash("0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Sin : app_name=Market : server=Live")
          actual.should == expected
        end
 
        it "should handle no actions" do
          expected = { :action => "UNKNOWN_ACTION", :timestamp => "2010-09-21 23:15:20", :server => "Live", :app_name => 'Market' }
-         actual = Appstats::Logger.entry_to_hash("0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 app_name=Market : server=Live")
+         actual = Appstats::Logger.entry_to_hash("0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 app_name=Market : server=Live")
          actual.should == expected
        end
     
        it "should handle actions with the delimiter (and change the delimiter)" do
          expected = { :action => "address:=search-n", :timestamp => "2010-09-21 23:15:20" }
-         actual = Appstats::Logger.entry_to_hash("0.15.1 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=search-n")
+         actual = Appstats::Logger.entry_to_hash("0.16.1 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=search-n")
          actual.should == expected
     
          expected = { :action => "address::search==--n", :timestamp => "2010-09-21 23:15:20" }
-         actual = Appstats::Logger.entry_to_hash("0.15.1 setup[:::,===,---n] 2010-09-21 23:15:20 action===address::search==--n")
+         actual = Appstats::Logger.entry_to_hash("0.16.1 setup[:::,===,---n] 2010-09-21 23:15:20 action===address::search==--n")
          actual.should == expected
        end
     
        it "should handle contexts with the delimiter (and change the delimiter)" do
          expected = { :action => "address", :timestamp => "2010-09-21 23:15:20", :server => "market:eval=-n" }
-         actual = Appstats::Logger.entry_to_hash("0.15.1 setup[::,==,--n] 2010-09-21 23:15:20 action==address :: server==market:eval=-n")
+         actual = Appstats::Logger.entry_to_hash("0.16.1 setup[::,==,--n] 2010-09-21 23:15:20 action==address :: server==market:eval=-n")
          actual.should == expected
        end
        
@@ -196,66 +196,66 @@ module Appstats
     describe "#entry_to_s" do
       
       it "should handle a statistics entry" do
-        expected = "0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search"
+        expected = "0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search"
         actual = Appstats::Logger.entry_to_s("address_search")
         actual.should == expected
       end
       
       it "should handle numbers" do
-        expected = "0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=1 : note=2.2"
+        expected = "0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=1 : note=2.2"
         actual = Appstats::Logger.entry_to_s(1,:note => 2.2)
         actual.should == expected
       end
       
       it "should handle default contexts" do
         Appstats::Logger.default_contexts[:app_name] = "market"
-        expected = "0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search : app_name=market"
+        expected = "0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search : app_name=market"
         actual = Appstats::Logger.entry_to_s("address_search")
         actual.should == expected
       end
       
       it "should handle contexts (and sort them by symbol)" do
-        expected = "0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live"
+        expected = "0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_filter : app_name=Market : server=Live"
         actual = Appstats::Logger.entry_to_s("address_filter", { :server => "Live", :app_name => 'Market' })
         actual.should == expected
       end
 
       it "should handle actions with the delimiter (and change the delimiter)" do
-        expected = "0.15.1 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=search-n"
+        expected = "0.16.1 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=search-n"
         actual = Appstats::Logger.entry_to_s("address:=search-n")
         actual.should == expected
 
-        expected = "0.15.1 setup[:::,===,---n] 2010-09-21 23:15:20 action===address::search==--n"
+        expected = "0.16.1 setup[:::,===,---n] 2010-09-21 23:15:20 action===address::search==--n"
         actual = Appstats::Logger.entry_to_s("address::search==--n")
         actual.should == expected
       end
 
       it "should handle contexts with the delimiter (and change the delimiter)" do
-        expected = "0.15.1 setup[::,==,--n] 2010-09-21 23:15:20 action==address :: server==market:eval=-n"
+        expected = "0.16.1 setup[::,==,--n] 2010-09-21 23:15:20 action==address :: server==market:eval=-n"
         actual = Appstats::Logger.entry_to_s("address", :server => 'market:eval=-n')
         actual.should == expected
       end
 
       it "should ignore spaces" do
-        expected = "0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address search"
+        expected = "0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address search"
         actual = Appstats::Logger.entry_to_s("address search")
         actual.should == expected
       end
       
       it "should convert newlines in action" do
-        expected = "0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_-nsearch"
+        expected = "0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_-nsearch"
         actual = Appstats::Logger.entry_to_s("address_\nsearch")
         actual.should == expected
       end
 
       it "should convert newlines in context" do
-        expected = "0.15.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search : blah=some-nlong-nstatement"
+        expected = "0.16.1 setup[:,=,-n] 2010-09-21 23:15:20 action=address_search : blah=some-nlong-nstatement"
         actual = Appstats::Logger.entry_to_s("address_search",:blah => "some\nlong\nstatement")
         actual.should == expected
       end
       
       it "should convert newlines based on the delimiter" do
-        expected = "0.15.1 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=--nsearch-n"
+        expected = "0.16.1 setup[::,==,--n] 2010-09-21 23:15:20 action==address:=--nsearch-n"
         actual = Appstats::Logger.entry_to_s("address:=\nsearch-n")
         actual.should == expected
       end

data/spec/query_spec.rb

@@ -15,69 +15,111 @@ module Appstats
       
       it "should set input to nil" do
         @query.query.should == nil
+        @query.query_type.should == nil
       end
       
-      it "should allow query on constructor" do
-        query = Appstats::Query.new(:query => "# logins")
-        query.query.should == "# logins"
-      end
-      
-    end
-    
-    describe "#input" do
-    
-      it "should set the inputs to nil if input invalid" do
-        query = Appstats::Query.new(:query => "# myblahs today on xyz.localnet")
-        query.query = nil
-        query.action.should == nil
-        query.host.should == nil
-        query.date_range.should == DateRange.new
-        query.group_by.should == []
-        query.group_query_to_sql.should == nil
-      end
-    
-      it "should set the action and host" do
-        query = Appstats::Query.new(:query => "# myblahs today on xyz.localnet")
-        query.action.should == "myblahs"
-        query.host.should == "xyz.localnet"
-        query.date_range.should == DateRange.parse("today")
-        query.group_by.should == []
-        query.group_query_to_sql.should == nil
-      end
-    
-      it "should understand the short hand 'on' instead of 'on server'" do
-        query = Appstats::Query.new(:query => "# myblahs on xyz.localnet")
-        query.action.should == "myblahs"
-        query.host.should == "xyz.localnet"
-        query.date_range.should == DateRange.new
-        query.group_by.should == []
-        query.group_query_to_sql.should == nil
-      end
-    
-      it "should understand the old 'on server' instead of new 'on'" do
-        query = Appstats::Query.new(:query => "# myblahs on server xyz.localnet")
-        query.action.should == "myblahs"
-        query.host.should == "xyz.localnet"
-        query.date_range.should == DateRange.new
-        query.group_by.should == []
-        query.group_query_to_sql.should == nil
+      describe "query_type" do
+
+        it "should allow simple objects" do
+          query = Appstats::Query.new(:query => "# logins", :query_type => "YetAnotherTestQuery")
+          query.query.should == "# logins"
+          query.query_type.should == "YetAnotherTestQuery"
+        end
+
+        it "should allow modules" do
+          query = Appstats::Query.new(:query => "# logins", :query_type => "Appstats::TestQuery")
+          query.query.should == "# logins"
+          query.query_type.should == "Appstats::TestQuery"
+        end
+
+        it "should allow sub modules" do
+          query = Appstats::Query.new(:query => "# logins", :query_type => "Appstats::Core::AnotherTestQuery")
+          query.query.should == "# logins"
+          query.query_type.should == "Appstats::Core::AnotherTestQuery"
+        end
+
+        it "should fail for invalid query type" do
+
+          lambda { Appstats::Query.new(:query => "# logins", :query_type => "x") }.should raise_error
+        end
+        
       end
 
-      describe "group by" do
+      describe "default query type" do
+
+        it "should set the inputs to nil if input invalid" do
+          query = Appstats::Query.new(:query => "# myblahs today on xyz.localnet")
+          query.query = nil
+          query.action.should == nil
+          query.host.should == nil
+          query.date_range.should == DateRange.new
+          query.group_by.should == []
+          query.group_query_to_sql.should == nil
+        end
+
+        it "should set the action and host" do
+          query = Appstats::Query.new(:query => "# myblahs today on xyz.localnet")
+          query.action.should == "myblahs"
+          query.host.should == "xyz.localnet"
+          query.date_range.should == DateRange.parse("today")
+          query.group_by.should == []
+          query.group_query_to_sql.should == nil
+        end
+
+        it "should understand the short hand 'on' instead of 'on server'" do
+          query = Appstats::Query.new(:query => "# myblahs on xyz.localnet")
+          query.action.should == "myblahs"
+          query.host.should == "xyz.localnet"
+          query.date_range.should == DateRange.new
+          query.group_by.should == []
+          query.group_query_to_sql.should == nil
+        end
 
-        it "should handle single entry" do
-          query = Appstats::Query.new(:query => "# myblahs group by aa")
-          query.group_by.should == ["aa"]
+        it "should understand the old 'on server' instead of new 'on'" do
+          query = Appstats::Query.new(:query => "# myblahs on server xyz.localnet")
+          query.action.should == "myblahs"
+          query.host.should == "xyz.localnet"
+          query.date_range.should == DateRange.new
+          query.group_by.should == []
+          query.group_query_to_sql.should == nil
         end
 
-        it "should handle multi-entry" do
-          query = Appstats::Query.new(:query => "# myblahs group by aa,bbbb")
-          query.group_by.should == ["aa","bbbb"]
+        describe "group by" do
+
+          it "should handle single entry" do
+            query = Appstats::Query.new(:query => "# myblahs group by aa")
+            query.group_by.should == ["aa"]
+          end
+
+          it "should handle multi-entry" do
+            query = Appstats::Query.new(:query => "# myblahs group by aa,bbbb")
+            query.group_by.should == ["aa","bbbb"]
+          end
+
+        end
+        
+        describe "contexts" do
+
+          it "should handle single entry" do
+            query = Appstats::Query.new(:query => "# myblahs where aa = bb or aa < ccc")
+            query.contexts.should == "aa = bb or aa < ccc"
+            query.parsed_contexts.should == [ { :context_key => "aa", :comparator => "=", :context_value => "bb" }, "or", { :context_key => "aa", :comparator => "<", :context_value => "ccc" } ]
+          end
+
+        end        
+        
+      end
+      
+      describe "distinct query_type" do
+        
+        it "should delete sql to other queries" do
+          query = Appstats::Query.new(:query => "# stuff", :query_type => "Appstats::TestQuery")
+          query.query_to_sql.should == "select count(*) as num from appstats_test_objects"
+          query.group_query_to_sql.should == "select context_key_filter, context_value_filter, count(*) as num from (select 'name' as context_key_filter, name as context_value_filter from appstats_test_objects) results group by context_value_filter"
         end
         
       end
 
-    
     end
     
     describe "#run" do
@@ -91,14 +133,14 @@ module Appstats
           query = Appstats::Query.new(:query => "# blahs")
           result = query.run
           result.new_record?.should == false
-          result.should == Appstats::Result.new(:result_type => "on_demand", :query => "# blahs", :query_as_sql => query.query_to_sql, :count => 0, :action => "blahs", :group_by => nil)
+          result.should == Appstats::Result.new(:result_type => "on_demand", :query => "# blahs", :query_to_sql => query.query_to_sql, :count => 0, :action => "blahs", :group_by => nil)
         end
 
         it "should set name and result_type if provided" do
           query = Appstats::Query.new(:name => "x", :result_type => "some_reason", :query => "# blahs")
           result = query.run
           result.new_record?.should == false
-          result.should == Appstats::Result.new(:name => "x", :result_type => "some_reason", :query => "# blahs", :query_as_sql => query.query_to_sql, :count => 0, :action => "blahs", :group_by => nil)
+          result.should == Appstats::Result.new(:name => "x", :result_type => "some_reason", :query => "# blahs", :query_to_sql => query.query_to_sql, :count => 0, :action => "blahs", :group_by => nil)
         end
 
         it "should track contexts" do
@@ -211,21 +253,81 @@ module Appstats
         it "should track sub results for multiple group by" do
           Appstats::Entry.create_from_logger("myblahs",:service_provider => "a", :user => "1")
           Appstats::Entry.create_from_logger("myblahs",:service_provider => "a", :user => "1")
+          Appstats::Entry.create_from_logger("myblahs",:service_provider => "a", :user => "1")
+          Appstats::Entry.create_from_logger("myblahs",:service_provider => "a", :user => "1")
+          Appstats::Entry.create_from_logger("myblahs",:service_provider => "a", :user => "1")
+
           Appstats::Entry.create_from_logger("myblahs",:service_provider => "a", :user => "2")
+          Appstats::Entry.create_from_logger("myblahs",:service_provider => "a", :user => "2")
+
+          Appstats::Entry.create_from_logger("myblahs",:service_provider => "b", :user => "1")
+          Appstats::Entry.create_from_logger("myblahs",:service_provider => "b", :user => "1")
           Appstats::Entry.create_from_logger("myblahs",:service_provider => "b", :user => "1")
           
           query = Appstats::Query.new(:query => "# myblahs group by service_provider,user")
           result = query.run
-          result.count.should == 4
+          result.count.should == 10
           result.group_by.should == "service_provider, user"
           result.sub_results.size.should == 3
           
-          result.sub_results[0].should == SubResult.new(:context_filter => "a, 1", :count => 2, :ratio_of_total => 0.50)
-          result.sub_results[1].should == SubResult.new(:context_filter => "b, 1", :count => 1, :ratio_of_total => 0.25)
-          result.sub_results[2].should == SubResult.new(:context_filter => "a, 2", :count => 1, :ratio_of_total => 0.25)
+          result.sub_results[0].should == SubResult.new(:context_filter => "a, 1", :count => 5, :ratio_of_total => 0.50)
+          result.sub_results[1].should == SubResult.new(:context_filter => "b, 1", :count => 3, :ratio_of_total => 0.30)
+          result.sub_results[2].should == SubResult.new(:context_filter => "a, 2", :count => 2, :ratio_of_total => 0.20)
         end        
         
       end
+      
+      describe "third party searches" do
+        
+        before(:each) do
+          TestObject.delete_all
+          
+        end
+        
+        it "should handle custom sql" do
+          TestObject.create and TestObject.create
+          
+          query = Query.new(:query => "# x", :query_type => "Appstats::TestQuery")
+          result = query.run
+          
+          result.query_type.should == "Appstats::TestQuery"
+          result.count.should == 2
+          result.query_to_sql.should == "select count(*) as num from appstats_test_objects"
+        end
+
+        it "should handle group by" do
+          TestObject.create(:name => "aa") and TestObject.create(:name => "aa") and TestObject.create(:name => "bb")
+          
+          query = Query.new(:query => "# x group by y", :query_type => "Appstats::TestQuery")
+          result = query.run
+          
+          result.query_type.should == "Appstats::TestQuery"
+          result.count.should == 3
+          result.group_query_to_sql.should == "select context_key_filter, context_value_filter, count(*) as num from (select 'name' as context_key_filter, name as context_value_filter from appstats_test_objects) results group by context_value_filter"
+          result.sub_results.size.should == 2
+        end
+        
+        it "should handle remote servers" do
+          TestObject.create(:name => "aa")
+          
+          query1 = Query.new(:query => "# x on testServer", :query_type => "Appstats::TestQuery")
+          result1 = query1.run
+
+          query2 = Query.new(:query => "# x on otherServer", :query_type => "Appstats::TestQuery")
+          result2 = query2.run
+          
+          if result2.count == result1.count #coincidence
+            TestObject.create(:name => "aa")
+            result2 = query2.run
+          end
+
+          result1.count.should_not == result2.count
+
+          result1 = query1.run
+          result1.count.should_not == result2.count
+        end
+        
+      end
 
     end
     
@@ -247,13 +349,13 @@ module Appstats
       describe "actions" do
         
         it "should understand both singular and plural names" do
-          expected_sql = "select count(*) from appstats_entries where action = 'login'"
+          expected_sql = "select count(*) as num from appstats_entries where action = 'login'"
           Appstats::Query.new(:query => "# logins").query_to_sql.should == expected_sql
           Appstats::Query.new(:query => "# login").query_to_sql.should == expected_sql
         end
         
         it "should use 'itself' if action not found" do
-          expected_sql = "select count(*) from appstats_entries where action = 'garblygook'"
+          expected_sql = "select count(*) as num from appstats_entries where action = 'garblygook'"
           Appstats::Query.new(:query => "# garblygook").query_to_sql.should == expected_sql
         end
         
@@ -261,7 +363,7 @@ module Appstats
       
       describe "date ranges" do
         it "should understand since dates" do
-          expected_sql = "select count(*) from appstats_entries where action = 'login' and occurred_at >= '2010-01-15 00:00:00'"
+          expected_sql = "select count(*) as num from appstats_entries where action = 'login' and occurred_at >= '2010-01-15 00:00:00'"
           Appstats::Query.new(:query => "# logins since 2010-01-15").query_to_sql.should == expected_sql
         end
       end
@@ -269,7 +371,7 @@ module Appstats
       describe "server_name" do
         
         it "should on_name" do
-          expected_sql = "select count(*) from appstats_entries where action = 'login' and EXISTS (select * from appstats_log_collectors where appstats_entries.appstats_log_collector_id = appstats_log_collectors.id and host = 'my.localnet' )"
+          expected_sql = "select count(*) as num from appstats_entries where action = 'login' and EXISTS (select * from appstats_log_collectors where appstats_entries.appstats_log_collector_id = appstats_log_collectors.id and host = 'my.localnet' )"
           Appstats::Query.new(:query => "# logins on my.localnet").query_to_sql.should == expected_sql
         end
     
@@ -277,7 +379,7 @@ module Appstats
       
       describe "date range and server_name" do
         it "should understand  dates and 'on'" do
-          expected_sql = "select count(*) from appstats_entries where action = 'login' and (occurred_at >= '2010-01-15 00:00:00' and occurred_at <= '2010-01-31 23:59:59') and EXISTS (select * from appstats_log_collectors where appstats_entries.appstats_log_collector_id = appstats_log_collectors.id and host = 'your.localnet' )"
+          expected_sql = "select count(*) as num from appstats_entries where action = 'login' and (occurred_at >= '2010-01-15 00:00:00' and occurred_at <= '2010-01-31 23:59:59') and EXISTS (select * from appstats_log_collectors where appstats_entries.appstats_log_collector_id = appstats_log_collectors.id and host = 'your.localnet' )"
           Appstats::Query.new(:query => "# logins between 2010-01-15 and 2010-01-31 on your.localnet").query_to_sql.should == expected_sql
         end
       end
@@ -285,12 +387,12 @@ module Appstats
      describe "where clause" do
        
        it "should understand no quotes" do
-         expected_sql = "select count(*) from appstats_entries where action = 'login' and EXISTS (select * from appstats_contexts where appstats_entries.id = appstats_contexts.appstats_entry_id and ( (context_key = 'user' and context_value = 'aforward')))"
+         expected_sql = "select count(*) as num from appstats_entries where action = 'login' and EXISTS (select * from appstats_contexts where appstats_entries.id = appstats_contexts.appstats_entry_id and ( (context_key = 'user' and context_value = 'aforward')))"
          Appstats::Query.new(:query => "# logins where user = aforward").query_to_sql.should == expected_sql
        end
        
        it "should handle example" do
-         expected_sql = "select count(*) from appstats_entries where action = 'blahs' and EXISTS (select * from appstats_contexts where appstats_entries.id = appstats_contexts.appstats_entry_id and ( ( (context_key = 'a' and context_value = 'b') and (context_key = 'c' and context_value = '4') ) or ( (context_key = 'aaa' and context_value = '5') )))"
+         expected_sql = "select count(*) as num from appstats_entries where action = 'blahs' and EXISTS (select * from appstats_contexts where appstats_entries.id = appstats_contexts.appstats_entry_id and ( ( (context_key = 'a' and context_value = 'b') and (context_key = 'c' and context_value = '4') ) or ( (context_key = 'aaa' and context_value = '5') )))"
          Appstats::Query.new(:query => "# blahs where (a=b and c=4) or (aaa=5)").query_to_sql.should == expected_sql
         end
        
@@ -331,26 +433,26 @@ module Appstats
             
       it "should support 1 filter" do
         query = Appstats::Query.new(:query => "# myblahs group by aa")
-        expected = "select context_key_filter, context_value_filter, count(*) num from (select group_concat(appstats_contexts.context_key) as context_key_filter, group_concat(appstats_contexts.context_value) as context_value_filter, appstats_entry_id from appstats_contexts where context_key in ('aa') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_value_filter;"
+        expected = "select context_key_filter, context_value_filter, count(*) as num from (select group_concat(appstats_contexts.context_key) as context_key_filter, group_concat(appstats_contexts.context_value) as context_value_filter, appstats_entry_id from appstats_contexts where context_key in ('aa') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_value_filter"
         query.group_query_to_sql.should == expected
       end
 
       it "should support surrounding quotes" do
         query = Appstats::Query.new(:query => "# myblahs group by 'aa'")
-        expected = "select context_key_filter, context_value_filter, count(*) num from (select group_concat(appstats_contexts.context_key) as context_key_filter, group_concat(appstats_contexts.context_value) as context_value_filter, appstats_entry_id from appstats_contexts where context_key in ('aa') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_value_filter;"
+        expected = "select context_key_filter, context_value_filter, count(*) as num from (select group_concat(appstats_contexts.context_key) as context_key_filter, group_concat(appstats_contexts.context_value) as context_value_filter, appstats_entry_id from appstats_contexts where context_key in ('aa') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_value_filter"
         query.group_query_to_sql.should == expected
       end
 
       it "should support inner quotes" do
         query = Appstats::Query.new(:query => "# myblahs group by a's")
-        expected = "select context_key_filter, context_value_filter, count(*) num from (select group_concat(appstats_contexts.context_key) as context_key_filter, group_concat(appstats_contexts.context_value) as context_value_filter, appstats_entry_id from appstats_contexts where context_key in ('a''s') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_value_filter;"
+        expected = "select context_key_filter, context_value_filter, count(*) as num from (select group_concat(appstats_contexts.context_key) as context_key_filter, group_concat(appstats_contexts.context_value) as context_value_filter, appstats_entry_id from appstats_contexts where context_key in ('a''s') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_value_filter"
         query.group_query_to_sql.should == expected
       end
 
 
       it "should support many filters" do
         query = Appstats::Query.new(:query => "# myblahs group by aa, bbb")
-        expected = "select context_key_filter, context_value_filter, count(*) num from (select group_concat(appstats_contexts.context_key) as context_key_filter, group_concat(appstats_contexts.context_value) as context_value_filter, appstats_entry_id from appstats_contexts where context_key in ('aa','bbb') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_value_filter;"
+        expected = "select context_key_filter, context_value_filter, count(*) as num from (select group_concat(appstats_contexts.context_key) as context_key_filter, group_concat(appstats_contexts.context_value) as context_value_filter, appstats_entry_id from appstats_contexts where context_key in ('aa','bbb') and appstats_entry_id in ( #{@template} ) group by appstats_entry_id) results group by context_value_filter"
         query.group_query_to_sql.should == expected
       end
       
@@ -364,43 +466,43 @@ module Appstats
       end
       
       it "should translate a = b into EXISTS query" do
-        Appstats::Query.contexts_filter_to_sql("a=b").should == "#{@template} (context_key = 'a' and context_value = 'b')))"
-        Appstats::Query.contexts_filter_to_sql(" a =  b ").should == "#{@template} (context_key = 'a' and context_value = 'b')))"
+        Appstats::Query.new(:query => "# logins where a=b").contexts_filter_to_sql.should == "#{@template} (context_key = 'a' and context_value = 'b')))"
+        Appstats::Query.new(:query => "# logins where a  =  b   ").contexts_filter_to_sql.should == "#{@template} (context_key = 'a' and context_value = 'b')))"
       end
           
       it "should ignore single quotes" do
-        Appstats::Query.contexts_filter_to_sql("'aaa'='bbbb'").should == "#{@template} (context_key = 'aaa' and context_value = 'bbbb')))"
-        Appstats::Query.contexts_filter_to_sql(" 'aaa' = 'bbbb'  ").should == "#{@template} (context_key = 'aaa' and context_value = 'bbbb')))"
+        Appstats::Query.new(:query => "# logins where 'aaa'='bbbb'").contexts_filter_to_sql.should == "#{@template} (context_key = 'aaa' and context_value = 'bbbb')))"
+        Appstats::Query.new(:query => "# logins where 'aaa' = 'bbbb'  ").contexts_filter_to_sql.should == "#{@template} (context_key = 'aaa' and context_value = 'bbbb')))"
       end
       
       it "should allow for searching for all entries of a certain context" do
-        Appstats::Query.contexts_filter_to_sql("aaa").should == "#{@template} (context_key = 'aaa')))"
+        Appstats::Query.new(:query => "# logins where aaa").contexts_filter_to_sql.should == "#{@template} (context_key = 'aaa')))"
       end
       
       it "should allow for searching for several entries of a certain context" do
-        Appstats::Query.contexts_filter_to_sql("aaa || bbb").should == "#{@template} (context_key = 'aaa') or (context_key = 'bbb')))"
+        Appstats::Query.new(:query => "# logins where aaa || bbb").contexts_filter_to_sql.should == "#{@template} (context_key = 'aaa') or (context_key = 'bbb')))"
       end
     
       it "should allow complex queries" do
-        Appstats::Query.contexts_filter_to_sql("user='andrew' || user='aforward'").should == "#{@template} (context_key = 'user' and context_value = 'andrew') or (context_key = 'user' and context_value = 'aforward')))"
+        Appstats::Query.new(:query => "# logins where user='andrew' || user='aforward'").contexts_filter_to_sql.should == "#{@template} (context_key = 'user' and context_value = 'andrew') or (context_key = 'user' and context_value = 'aforward')))"
       end
     
       it "should support or" do
-        Appstats::Query.contexts_filter_to_sql("user='andrew' or user='aforward'").should == "#{@template} (context_key = 'user' and context_value = 'andrew') or (context_key = 'user' and context_value = 'aforward')))"
+        Appstats::Query.new(:query => "# logins where user='andrew' or user='aforward'").contexts_filter_to_sql.should == "#{@template} (context_key = 'user' and context_value = 'andrew') or (context_key = 'user' and context_value = 'aforward')))"
       end
     
       it "should support like" do
-        Appstats::Query.contexts_filter_to_sql("user like '%andrew%'").should == "#{@template} (context_key = 'user' and context_value like '%andrew%')))"
+        Appstats::Query.new(:query => "# logins where user like '%andrew%'").contexts_filter_to_sql.should == "#{@template} (context_key = 'user' and context_value like '%andrew%')))"
       end
     
       it "should support and" do
-        Appstats::Query.contexts_filter_to_sql("user='andrew' and user='aforward'").should == "#{@template} (context_key = 'user' and context_value = 'andrew') and (context_key = 'user' and context_value = 'aforward')))"
+        Appstats::Query.new(:query => "# logins where user='andrew' and user='aforward'").contexts_filter_to_sql.should == "#{@template} (context_key = 'user' and context_value = 'andrew') and (context_key = 'user' and context_value = 'aforward')))"
       end
     
       
       it "should do simple 1 = 1 if invalid" do
-        Appstats::Query.contexts_filter_to_sql("").should == "1=1"
-        Appstats::Query.contexts_filter_to_sql(nil).should == "1=1"
+        Appstats::Query.new(:query => "# logins where").contexts_filter_to_sql.should == "1=1"
+        Appstats::Query.new(:query => "# logins").contexts_filter_to_sql.should == "1=1"
       end
       
     end

data/spec/result_job_spec.rb

@@ -20,15 +20,17 @@ module Appstats
         @result_job.status.should == nil
         @result_job.query.should == nil
         @result_job.last_run_at.should == nil
+        @result_job.query_type.should == nil
       end
     
       it "should set on constructor" do
-        result = Appstats::ResultJob.new(:name => 'a', :frequency => 'b', :status => 'c', :query => 'd', :last_run_at => Time.parse("2010-02-03"))
-        result.name.should == 'a'
-        result.frequency.should == 'b'
-        result.status.should == 'c'
-        result.query.should == 'd'
-        result.last_run_at.to_s.should == Time.parse("2010-02-03").to_s
+        result_job = Appstats::ResultJob.new(:name => 'a', :frequency => 'b', :status => 'c', :query => 'd', :last_run_at => Time.parse("2010-02-03"), :query_type => 'e')
+        result_job.name.should == 'a'
+        result_job.frequency.should == 'b'
+        result_job.status.should == 'c'
+        result_job.query.should == 'd'
+        result_job.last_run_at.to_s.should == Time.parse("2010-02-03").to_s
+        result_job.query_type.should == 'e'
       end
     
     end

data/spec/result_spec.rb

@@ -14,21 +14,22 @@ module Appstats
         @result.name.should == nil
         @result.result_type.should == nil
         @result.query.should == nil
-        @result.query_as_sql.should == nil
+        @result.query_to_sql.should == nil
         @result.count.should == nil
         @result.action.should == nil
         @result.contexts.should == nil
         @result.from_date.should == nil
         @result.to_date.should == nil
         @result.group_by.should == nil
+        @result.query_type.should == nil
       end
     
       it "should set on constructor" do
-        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"), :group_by => "a,b")
+        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_to_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"), :group_by => "a,b", :query_type => 'h')
         result.name.should == 'a'
         result.result_type.should == 'b'
         result.query.should == 'c'
-        result.query_as_sql.should == 'd'
+        result.query_to_sql.should == 'd'
         result.count.should == 10
         result.action.should == 'e'
         result.host.should == 'f'
@@ -36,6 +37,7 @@ module Appstats
         result.from_date_to_s.should == '2010-01-02'
         result.to_date_to_s.should == '2010-02-03'
         result.group_by.should == "a,b"
+        result.query_type.should == "h"
       end
     
     end
@@ -43,16 +45,16 @@ module Appstats
     describe "#==" do
       
       it "should be equal on all attributes" do
-        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"), :group_by => "a,b")
-        same_result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"), :group_by => "a,b")
+        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_to_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"), :group_by => "a,b", :query_type => 'h')
+        same_result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_to_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"), :group_by => "a,b", :query_type => 'h')
         (result == same_result).should == true
       end
       
       it "should be not equal if diferent attributes" do
-        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"), :group_by => "a,b")
+        result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_to_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"), :group_by => "a,b", :query_type => 'h')
         
-        [:name,:result_type,:query,:query_as_sql,:count,:action,:host,:contexts,:from_date,:to_date,:group_by].each do |attr|
-          different_result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_as_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"), :group_by => "a,b")  
+        [:name,:result_type,:query,:query_to_sql,:count,:action,:host,:contexts,:from_date,:to_date,:group_by,:query_type].each do |attr|
+          different_result = Appstats::Result.new(:name => 'a', :result_type => 'b', :query => 'c', :query_to_sql => 'd', :count => 10, :action => 'e', :host => 'f', :contexts => 'g', :from_date => Time.parse("2010-01-02"), :to_date => Time.parse("2010-02-03"), :group_by => "a,b", :query_type => 'h')  
 
           if [:from_date,:to_date].include?(attr)
             different_result.send("#{attr}=",Time.parse("2011-01-02"))

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: appstats
 version: !ruby/object:Gem::Version 
-  hash: 33
+  hash: 93
   prerelease: false
   segments: 
   - 0
-  - 15
+  - 16
   - 1
-  version: 0.15.1
+  version: 0.16.1
 platform: ruby
 authors: 
 - Andrew Forward
@@ -162,6 +162,8 @@ files:
 - db/migrations/20110301170733_add_appstats_results_group_query_to_sql.rb
 - db/migrations/20110301170947_create_appstats_sub_results.rb
 - db/migrations/20110301195959_add_appstats_results_groups.rb
+- db/migrations/20110301212017_add_appstats_results_query_type.rb
+- db/migrations/20110301230757_rename_appstats_results_query_as_sql_to_query_to_sql.rb
 - db/schema.rb
 - lib/appstats.rb
 - lib/appstats/action.rb
@@ -183,6 +185,7 @@ files:
 - lib/appstats/sub_result.rb
 - lib/appstats/tasks.rb
 - lib/appstats/test_object.rb
+- lib/appstats/test_query.rb
 - lib/appstats/version.rb
 - lib/daemons/appstats_log_collector.rb
 - lib/daemons/appstats_log_collector_ctl