From 728e51f6b0e2b2b19da79dbf09595ebdd73d1a6f Mon Sep 17 00:00:00 2001 From: Jamie Macey Date: Fri, 4 Jul 2008 15:18:51 -0400 Subject: [PATCH] move code --- lib/ultrasphinx/configure.rb | 179 +++++++++++++++++------------------ 1 file changed, 88 insertions(+), 91 deletions(-) diff --git a/lib/ultrasphinx/configure.rb b/lib/ultrasphinx/configure.rb index 35a9227..af05fa7 100644 --- a/lib/ultrasphinx/configure.rb +++ b/lib/ultrasphinx/configure.rb @@ -199,95 +199,9 @@ def build_delta_condition def build_regular_fields @options['fields'].to_a.each do |entry| - source_string = "#{entry['table_alias']}.#{entry['field']}" - @group_bys << source_string - install_field(Fields.instance, source_string, entry['as'], entry['function_sql'], entry['facet'], entry['sortable']) - end - end - - def install_field(fields, source_string, as, function_sql, with_facet, with_sortable, cs=nil, rs=nil) - source_string = function_sql._interpolate(source_string) if function_sql - - @column_strings << fields.cast(source_string, as) - @remaining_columns.delete(as) - - # Generate duplicate text fields for sorting - if with_sortable - @column_strings << fields.cast(source_string, "#{as}_sortable") - @remaining_columns.delete("#{as}_sortable") - end - - # Generate hashed integer fields for text grouping - if with_facet - @column_strings << "#{SQL_FUNCTIONS[ADAPTER]['hash']._interpolate(source_string)} AS #{as}_facet" - @remaining_columns.delete("#{as}_facet") - end - [@column_strings, @remaining_columns] - end - - - - def setup_source_database(klass) - # Supporting Postgres now - connection_settings = klass.connection.instance_variable_get("@config") - raise ConfigurationError, "Unsupported database adapter" unless connection_settings - - adapter_defaults = DEFAULTS[ADAPTER] - raise ConfigurationError, "Unsupported database adapter" unless adapter_defaults - - conf = [adapter_defaults] - connection_settings.reverse_merge(CONNECTION_DEFAULTS).each do |key, value| - conf << "#{CONFIG_MAP[key]} = #{value}" if CONFIG_MAP[key] - end - conf.sort.join("\n") - end - - def range_select_string(klass, delta_condition) - ["sql_query_range = SELECT", - SQL_FUNCTIONS[ADAPTER]['range_cast']._interpolate("MIN(#{klass.primary_key})"), - ",", - SQL_FUNCTIONS[ADAPTER]['range_cast']._interpolate("MAX(#{klass.primary_key})"), - "FROM #{klass.table_name}", - ("WHERE #{delta_condition}" if delta_condition), - ].join(" ") - end - - def query_info_string(klass, class_id) - "sql_query_info = SELECT * FROM #{klass.table_name} WHERE #{klass.table_name}.#{klass.primary_key} = (($id - #{class_id}) / #{MODEL_CONFIGURATION.size})" - end - - def build_query(klass, column_strings, join_strings, condition_strings, use_distinct, group_bys, order) - - primary_key = "#{klass.table_name}.#{klass.primary_key}" - group_bys = case ADAPTER - when 'mysql' - primary_key - when 'postgresql' - # Postgres is very fussy about GROUP_BY - ([primary_key] + group_bys.reject {|s| s == primary_key}.uniq.sort).join(', ') - end - - ["sql_query =", - "SELECT", - # Avoid DISTINCT; it destroys performance - column_strings.sort_by do |string| - # Sphinx wants them always in the same order, but "id" must be first - (field = string[/.*AS (.*)/, 1]) == "id" ? "*" : field - end.join(", "), - "FROM #{klass.table_name}", - join_strings.uniq, - "WHERE #{primary_key} >= $start AND #{primary_key} <= $end", - condition_strings.uniq.map {|condition| "AND #{condition}" }, - "GROUP BY #{group_bys}", - ("ORDER BY #{order}" if order) - ].flatten.compact.join(" ") - end - - def add_missing_columns(fields, remaining_columns, column_strings) - remaining_columns.each do |field| - column_strings << fields.null(field) + @group_bys << source_string = "#{entry['table_alias']}.#{entry['field']}" + install_field(source_string, entry['as'], entry['function_sql'], entry['facet'], entry['sortable']) end - column_strings end def build_includes(klass, fields, entries, column_strings, join_strings, group_bys, remaining_columns) @@ -315,7 +229,7 @@ def build_includes(klass, fields, entries, column_strings, join_strings, group_b source_string = "#{entry['table_alias']}.#{entry['field']}" group_bys << source_string - column_strings, remaining_columns = install_field(fields, source_string, entry['as'], entry['function_sql'], entry['facet'], entry['sortable'], column_strings, remaining_columns) + install_field(source_string, entry['as'], entry['function_sql'], entry['facet'], entry['sortable']) end [column_strings, join_strings, group_bys, remaining_columns] @@ -347,7 +261,7 @@ def build_concatenations(klass, fields, entries, column_strings, join_strings, g source_string = SQL_FUNCTIONS[ADAPTER]['group_concat']._interpolate(source_string, order_string) use_distinct = true - column_strings, remaining_columns = install_field(fields, source_string, entry['as'], entry['function_sql'], entry['facet'], entry['sortable'], column_strings, remaining_columns) + install_field(source_string, entry['as'], entry['function_sql'], entry['facet'], entry['sortable']) elsif entry['fields'] # Regular concats @@ -357,7 +271,7 @@ def build_concatenations(klass, fields, entries, column_strings, join_strings, g group_bys << subsource_string end.join(', ') + ")" - column_strings, remaining_columns = install_field(fields, source_string, entry['as'], entry['function_sql'], entry['facet'], entry['sortable'], column_strings, remaining_columns) + install_field(source_string, entry['as'], entry['function_sql'], entry['facet'], entry['sortable']) else raise ConfigurationError, "Invalid concatenate parameters for #{model}: #{entry.inspect}." @@ -367,6 +281,89 @@ def build_concatenations(klass, fields, entries, column_strings, join_strings, g [column_strings, join_strings, group_bys, use_distinct, remaining_columns] end + def add_missing_columns(fields, remaining_columns, column_strings) + remaining_columns.each do |field| + column_strings << fields.null(field) + end + column_strings + end + + def install_field(source_string, as, function_sql, with_facet, with_sortable) + source_string = function_sql._interpolate(source_string) if function_sql + + @column_strings << Fields.instance.cast(source_string, as) + @remaining_columns.delete(as) + + # Generate duplicate text fields for sorting + if with_sortable + @column_strings << Fields.instance.cast(source_string, "#{as}_sortable") + @remaining_columns.delete("#{as}_sortable") + end + + # Generate hashed integer fields for text grouping + if with_facet + @column_strings << "#{SQL_FUNCTIONS[ADAPTER]['hash']._interpolate(source_string)} AS #{as}_facet" + @remaining_columns.delete("#{as}_facet") + end + end + + + def setup_source_database(klass) + # Supporting Postgres now + connection_settings = klass.connection.instance_variable_get("@config") + raise ConfigurationError, "Unsupported database adapter" unless connection_settings + + adapter_defaults = DEFAULTS[ADAPTER] + raise ConfigurationError, "Unsupported database adapter" unless adapter_defaults + + conf = [adapter_defaults] + connection_settings.reverse_merge(CONNECTION_DEFAULTS).each do |key, value| + conf << "#{CONFIG_MAP[key]} = #{value}" if CONFIG_MAP[key] + end + conf.sort.join("\n") + end + + def range_select_string(klass, delta_condition) + ["sql_query_range = SELECT", + SQL_FUNCTIONS[ADAPTER]['range_cast']._interpolate("MIN(#{klass.primary_key})"), + ",", + SQL_FUNCTIONS[ADAPTER]['range_cast']._interpolate("MAX(#{klass.primary_key})"), + "FROM #{klass.table_name}", + ("WHERE #{delta_condition}" if delta_condition), + ].join(" ") + end + + def query_info_string(klass, class_id) + "sql_query_info = SELECT * FROM #{klass.table_name} WHERE #{klass.table_name}.#{klass.primary_key} = (($id - #{class_id}) / #{MODEL_CONFIGURATION.size})" + end + + def build_query(klass, column_strings, join_strings, condition_strings, use_distinct, group_bys, order) + + primary_key = "#{klass.table_name}.#{klass.primary_key}" + group_bys = case ADAPTER + when 'mysql' + primary_key + when 'postgresql' + # Postgres is very fussy about GROUP_BY + ([primary_key] + group_bys.reject {|s| s == primary_key}.uniq.sort).join(', ') + end + + ["sql_query =", + "SELECT", + # Avoid DISTINCT; it destroys performance + column_strings.sort_by do |string| + # Sphinx wants them always in the same order, but "id" must be first + (field = string[/.*AS (.*)/, 1]) == "id" ? "*" : field + end.join(", "), + "FROM #{klass.table_name}", + join_strings.uniq, + "WHERE #{primary_key} >= $start AND #{primary_key} <= $end", + condition_strings.uniq.map {|condition| "AND #{condition}" }, + "GROUP BY #{group_bys}", + ("ORDER BY #{order}" if order) + ].flatten.compact.join(" ") + end + def install_join_unless_association_sql(association_sql, join_string, join_strings) join_strings << (association_sql or join_string or yield) end