ebeigarts-thinking-sphinx 1.1.21 → 1.1.22

data/lib/thinking_sphinx.rb

@@ -39,7 +39,7 @@ module ThinkingSphinx
   module Version #:nodoc:
     Major = 1
     Minor = 1
-    Tiny  = 21
+    Tiny  = 22
     
     String = [Major, Minor, Tiny].join('.')
   end

data/lib/thinking_sphinx/adapters/oracle_adapter.rb

@@ -0,0 +1,122 @@
+module ThinkingSphinx
+  class OracleAdapter < AbstractAdapter
+    def setup
+      create_group_concat_function
+      create_crc32_function
+    end
+    
+    def sphinx_identifier
+      "odbc"
+    end
+    
+    def concatenate(clause, separator = ' ')
+      clause.split(', ').collect { |field| field }.join(" || '#{separator}' || ")
+    end
+    
+    def group_concatenate(clause, separator = ' ')
+      "TO_STRING(CAST(COLLECT(TO_CHAR(#{clause})) AS SYS.ODCIVARCHAR2LIST), '#{separator}')"
+    end
+    
+    def cast_to_string(clause)
+      "TO_CHAR(#{clause})"
+    end
+    
+    def cast_to_datetime(clause)
+      "(TO_DATE(TO_CHAR(#{clause}, 'YYYY-MON-DD HH24.MI.SS'), 'YYYY-MON-DD HH24.MI.SS') - TO_DATE('01-JAN-1970','DD-MON-YYYY')) * (86400)"
+    end
+    
+    def cast_to_unsigned(clause)
+      "CAST(#{clause} AS NUMBER(10,0))"
+    end
+    
+    def convert_nulls(clause, default = '')
+      return clause if default == ''
+      default = "'#{default}'" if default.is_a?(String)
+      "COALESCE(#{clause}, #{default})"
+    end
+    
+    def boolean(value)
+      value ? '1' : '0'
+    end
+    
+    # TODO
+    def crc(clause, blank_to_null = false)
+      "CRC32(#{clause})"
+    end
+    
+    def utf8_query_pre
+      nil
+    end
+    
+    def time_difference(diff)
+      "SYSDATE - #{diff}/(86400)"
+    end
+    
+    def select_each(query)
+      cursor = connection.raw_connection.exec(query)
+      col_names = cursor.get_col_names.collect(&:downcase)
+      while values = cursor.fetch
+        hash_values = Hash[*col_names.zip(values).flatten]
+        yield hash_values
+      end
+      cursor.close
+    end
+    
+    private
+    
+    # Requires Oracle 10g+
+    # Return only first 4000 bytes
+    def create_group_concat_function
+      connection.execute <<-SQL
+        CREATE OR REPLACE FUNCTION to_string (
+          nt_in IN SYS.ODCIVARCHAR2LIST,
+          delimiter_in IN VARCHAR2 DEFAULT ','
+        ) RETURN VARCHAR2 IS
+          v_idx PLS_INTEGER;
+          v_str VARCHAR2(4000);
+          v_dlm VARCHAR2(1);
+        BEGIN
+          v_idx := nt_in.FIRST;
+          WHILE v_idx IS NOT NULL LOOP
+            v_str := SUBSTRB(v_str || v_dlm || nt_in(v_idx), 1, 4000);
+            v_dlm := delimiter_in;
+            v_idx := nt_in.NEXT(v_idx);
+          END LOOP;
+          RETURN v_str;
+        END to_string;
+      SQL
+    end
+    
+    # Requires Oracle 10g+
+    def create_crc32_function
+      connection.execute <<-SQL
+        CREATE OR REPLACE FUNCTION crc32(
+          word IN VARCHAR2
+        ) RETURN NUMBER IS
+          code NUMBER(4,0);
+          i NUMBER(10,0);
+          j NUMBER(1,0);
+          tmp NUMBER(10,0);
+          tmp_a NUMBER(10,0);
+          tmp_b NUMBER(10,0);
+        BEGIN
+          tmp := 4294967295;
+          i := 0;
+          WHILE i < length(word) LOOP
+            code := ascii(SUBSTR(word, i + 1, 1));
+            tmp := tmp - 2 * to_number(bitand(tmp, code)) + code;
+            j := 0;
+            WHILE j < 8 LOOP
+              tmp_a := floor(tmp / 2);
+              tmp_b := 3988292384 * to_number(bitand(tmp, 1));
+              tmp := tmp_a - 2 * to_number(bitand(tmp_a, tmp_b)) + tmp_b;
+              j := j + 1;
+            END LOOP;
+            i := i + 1;
+          END LOOP;
+          RETURN tmp - 2 * to_number(bitand(tmp, 4294967295)) + 4294967295;
+        END crc32;
+      SQL
+    end
+  end
+end

data/lib/thinking_sphinx/adapters/sqlite3_adapter.rb

@@ -0,0 +1,91 @@
+module ThinkingSphinx
+  class SQLite3Adapter < AbstractAdapter
+    def setup
+      create_group_concat_function
+      create_crc32
+    end
+    
+    def sphinx_identifier
+      "sqlite3"
+    end
+    
+    def concatenate(clause, separator = ' ')
+      clause.split(', ').collect { |field| field }.join(" || '#{separator}' || ")
+    end
+    
+    def group_concatenate(clause, separator = ' ')
+      "GROUP_CONCAT(#{clause}, '#{separator}')"
+    end
+    
+    def cast_to_string(clause)
+      "CAST(#{clause} AS TEXT)"
+    end
+    
+    def cast_to_datetime(clause)
+      "STRFTIME('%s', #{clause})"
+    end
+    
+    def cast_to_unsigned(clause)
+      "CAST(#{clause} AS INTEGER)"
+    end
+    
+    def convert_nulls(clause, default = '')
+      return clause if default == ''
+      default = "'#{default}'" if default.is_a?(String)
+      "COALESCE(#{clause}, #{default})"
+    end
+    
+    def boolean(value)
+      value ? "'t'" : "'f'"
+    end
+    
+    def crc(clause, blank_to_null = false)
+      "CRC32(#{clause})"
+    end
+    
+    def utf8_query_pre
+      nil
+    end
+    
+    def time_difference(diff)
+      "STRFTIME('%s','now') - STRFTIME('%s', #{diff})"
+    end
+    
+    private
+    
+    def create_group_concat_function
+      connection.raw_connection.create_aggregate("group_concat", 2) do
+        step do |func, value, separator|
+          value = value.respond_to?(:to_s) ? value.to_s : ''
+          if String(func[:concat]).empty? then
+            func[:concat] = value
+          else
+            func[:concat] = func[:concat].to_s + separator.to_s + value
+          end
+        end
+        finalize do |func|
+          func.result = func[:concat]
+        end
+      end
+    end
+    
+    def create_crc32
+      connection.raw_connection.create_function("crc32", 1) do |func, value|
+        c = value.respond_to?(:to_s) ? value.to_s : ''
+        n = c.length
+        r = 0xFFFFFFFF
+        n.times do |i|
+          r ^= c[i]
+          8.times do
+            if (r & 1) != 0
+              r = (r >> 1) ^ 0xEDB88320
+            else
+              r >>= 1
+            end
+          end
+        end
+        func.result = r ^ 0xFFFFFFFF
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/attribute.rb

@@ -128,7 +128,7 @@ module ThinkingSphinx
     def config_value(offset = nil)
       if type == :multi && ThinkingSphinx::Configuration.instance.type != "xml"
         multi_config = include_as_association? ? "field" :
-          source_value(offset).gsub(/\n\s*/, " ").strip
+          source_value(offset).gsub(/\s+/m, " ").strip
         "uint #{unique_name} from #{multi_config}"
       else
         unique_name
@@ -195,24 +195,25 @@ module ThinkingSphinx
     end
     
     def query(offset)
-      assoc = association_for_mva
-      raise "Could not determine SQL for MVA" if assoc.nil?
+      base_assoc = base_association_for_mva
+      end_assoc  = end_association_for_mva
+      raise "Could not determine SQL for MVA" if base_assoc.nil?
       
       <<-SQL
-SELECT #{foreign_key_for_mva assoc}
+SELECT #{foreign_key_for_mva base_assoc}
   #{ThinkingSphinx.unique_id_expression(offset)} AS #{quote_column('id')},
-  #{primary_key_for_mva(assoc)} AS #{quote_column(unique_name)}
-FROM #{quote_table_name assoc.table}
+  #{primary_key_for_mva(end_assoc)} AS #{quote_column(unique_name)}
+FROM #{quote_table_name base_assoc.table} #{association_joins}
       SQL
     end
     
     def query_clause
-      foreign_key = foreign_key_for_mva association_for_mva
+      foreign_key = foreign_key_for_mva base_association_for_mva
       "WHERE #{foreign_key} >= $start AND #{foreign_key} <= $end"
     end
     
     def range_query
-      assoc       = association_for_mva
+      assoc       = base_association_for_mva
       foreign_key = foreign_key_for_mva assoc
       "SELECT MIN(#{foreign_key}), MAX(#{foreign_key}) FROM #{quote_table_name assoc.table}"
     end
@@ -227,12 +228,34 @@ FROM #{quote_table_name assoc.table}
       quote_with_table assoc.table, assoc.reflection.primary_key_name
     end
     
-    def association_for_mva
+    def end_association_for_mva
       @association_for_mva ||= associations[columns.first].detect { |assoc|
         assoc.has_column?(columns.first.__name)
       }
     end
     
+    def base_association_for_mva
+      @first_association_for_mva ||= begin
+        assoc = end_association_for_mva
+        while !assoc.parent.nil?
+          assoc = assoc.parent
+        end
+        
+        assoc
+      end
+    end
+    
+    def association_joins
+      joins = []
+      assoc = end_association_for_mva
+      while assoc != base_association_for_mva
+        joins << assoc.to_sql
+        assoc = assoc.parent
+      end
+      
+      joins.join(' ')
+    end
+    
     def is_many_ints?
       concat_ws? && all_ints?
     end

data/spec/unit/thinking_sphinx/attribute_spec.rb

@@ -321,6 +321,26 @@ describe ThinkingSphinx::Attribute do
     end
   end
   
+  describe "MVA via two has-many associations with a ranged source query" do
+    before :each do
+      @index  = ThinkingSphinx::Index.new(Alpha)
+      @source = ThinkingSphinx::Source.new(@index)
+      @attribute = ThinkingSphinx::Attribute.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:betas, :gammas, :value)],
+        :as => :gamma_values, :source => :ranged_query
+      )
+    end
+    
+    it "should use a ranged query" do
+      @attribute.type_to_config.should == :sql_attr_multi
+      
+      declaration, query, range_query = @attribute.config_value.split('; ')
+      declaration.should == "uint gamma_values from ranged-query"
+      query.should       == "SELECT `betas`.`alpha_id` #{ThinkingSphinx.unique_id_expression} AS `id`, `gammas`.`value` AS `gamma_values` FROM `betas` LEFT OUTER JOIN `gammas` ON gammas.beta_id = betas.id WHERE `betas`.`alpha_id` >= $start AND `betas`.`alpha_id` <= $end"
+      range_query.should == "SELECT MIN(`betas`.`alpha_id`), MAX(`betas`.`alpha_id`) FROM `betas`"
+    end
+  end
+  
   describe "with custom queries" do
     before :each do
       index = CricketTeam.sphinx_indexes.first

data/spec/unit/thinking_sphinx/configuration_spec.rb

@@ -12,7 +12,7 @@ describe ThinkingSphinx::Configuration do
       unless defined?(Merb)
         module ::Merb; end
       end
-            
+      
       ThinkingSphinx::Configuration.stub_method(:defined? => true)
       Merb.stub!(:environment => "merb_production")
       ThinkingSphinx::Configuration.environment.should == "merb_production"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ebeigarts-thinking-sphinx
 version: !ruby/object:Gem::Version 
-  version: 1.1.21
+  version: 1.1.22
 platform: ruby
 authors: 
 - Pat Allan
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-11 00:00:00 -07:00
+date: 2009-06-22 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -30,6 +30,8 @@ files:
 - lib/thinking_sphinx/active_record.rb
 - lib/thinking_sphinx/adapters/abstract_adapter.rb
 - lib/thinking_sphinx/adapters/mysql_adapter.rb
+- lib/thinking_sphinx/adapters/sqlite3_adapter.rb
+- lib/thinking_sphinx/adapters/oracle_adapter.rb
 - lib/thinking_sphinx/adapters/postgresql_adapter.rb
 - lib/thinking_sphinx/association.rb
 - lib/thinking_sphinx/attribute.rb
@@ -128,7 +130,7 @@ has_rdoc: true
 homepage: http://ts.freelancing-gods.com
 licenses: 
 post_install_message: |+
-  As of Thinking Sphinx 1.1.18, there is one important change to
+  With the release of Thinking Sphinx 1.1.18, there is one important change to
   note: previously, the default morphology for indexing was 'stem_en'. The new
   default is nil, to avoid any unexpected behavior. If you wish to keep the old
   value though, you will need to add the following settings to your