Module: ThinkingSphinx

Extended by:
SearchMethods::ClassMethods
Defined in:
lib/thinking_sphinx.rb,
lib/thinking_sphinx/join.rb,
lib/thinking_sphinx/facet.rb,
lib/thinking_sphinx/field.rb,
lib/thinking_sphinx/index.rb,
lib/thinking_sphinx/deltas.rb,
lib/thinking_sphinx/search.rb,
lib/thinking_sphinx/source.rb,
lib/thinking_sphinx/property.rb,
lib/thinking_sphinx/attribute.rb,
lib/thinking_sphinx/excerpter.rb,
lib/thinking_sphinx/source/sql.rb,
lib/thinking_sphinx/association.rb,
lib/thinking_sphinx/class_facet.rb,
lib/thinking_sphinx/core/string.rb,
lib/thinking_sphinx/auto_version.rb,
lib/thinking_sphinx/facet_search.rb,
lib/thinking_sphinx/active_record.rb,
lib/thinking_sphinx/configuration.rb,
lib/thinking_sphinx/index/builder.rb,
lib/thinking_sphinx/search_methods.rb,
lib/thinking_sphinx/rails_additions.rb,
lib/thinking_sphinx/rails_additions.rb,
lib/thinking_sphinx/rails_additions.rb,
lib/thinking_sphinx/rails_additions.rb,
lib/thinking_sphinx/rails_additions.rb,
lib/thinking_sphinx/index/faux_column.rb,
lib/thinking_sphinx/active_record/delta.rb,
lib/thinking_sphinx/active_record/scopes.rb,
lib/thinking_sphinx/deltas/default_delta.rb,
lib/thinking_sphinx/adapters/mysql_adapter.rb,
lib/thinking_sphinx/adapters/abstract_adapter.rb,
lib/thinking_sphinx/source/internal_properties.rb,
lib/thinking_sphinx/adapters/postgresql_adapter.rb,
lib/thinking_sphinx/active_record/attribute_updates.rb,
lib/thinking_sphinx/active_record/has_many_association.rb,
lib/thinking_sphinx/rails_additions.rb,
lib/thinking_sphinx/rails_additions.rb,
lib/thinking_sphinx/rails_additions.rb

Defined Under Namespace

Modules: AbstractQuotedTableName, ActiveRecord, ActiveRecordQuotedName, ActiveRecordStoreFullSTIClass, ArrayExtractOptions, ClassAttributeMethods, Core, Deltas, HashExcept, MysqlQuotedTableName, SearchMethods, SingletonClass Classes: AbstractAdapter, Association, Attribute, AutoVersion, ClassFacet, Configuration, ConnectionError, Context, Excerpter, Facet, FacetSearch, Field, Index, Join, MysqlAdapter, PostgreSQLAdapter, Property, Search, Source, StaleIdsException, Test

Constant Summary collapse

@@sphinx_mutex =

The collection of indexed models. Keep in mind that Rails lazily loads its classes, so this may not actually be populated with all the models that have Sphinx indexes.

Mutex.new
@@context = 
nil

Class Method Summary collapse

Methods included from SearchMethods::ClassMethods

count, facets, search, search_context, search_count, search_for_id, search_for_ids

Class Method Details

.context ⇒ Object 



69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/thinking_sphinx.rb', line 69

def self.context
  if @@context.nil?
    @@sphinx_mutex.synchronize do
      if @@context.nil?
        @@context = ThinkingSphinx::Context.new
        @@context.prepare
      end
    end
  end
  
  @@context
end

.define_indexes=(value) ⇒ Object

Enable/disable indexes - you may want to do this while migrating data.

ThinkingSphinx.define_indexes = false



106
107
108
 
# File 'lib/thinking_sphinx.rb', line 106

def self.define_indexes=(value)
  Thread.current[:thinking_sphinx_define_indexes] = value
end

.define_indexes? ⇒ Boolean

Check if index definition is disabled.



94
95
96
97
98
99
100
 
# File 'lib/thinking_sphinx.rb', line 94

def self.define_indexes?
  if Thread.current[:thinking_sphinx_define_indexes].nil?
    Thread.current[:thinking_sphinx_define_indexes] = true
  end
  
  Thread.current[:thinking_sphinx_define_indexes]
end

.deltas_enabled=(value) ⇒ Object

Enable/disable all delta indexing.

ThinkingSphinx.deltas_enabled = false



126
127
128
 
# File 'lib/thinking_sphinx.rb', line 126

def self.deltas_enabled=(value)
  Thread.current[:thinking_sphinx_deltas_enabled] = value
end

.deltas_enabled? ⇒ Boolean

Check if delta indexing is enabled.



112
113
114
115
116
117
118
119
120
 
# File 'lib/thinking_sphinx.rb', line 112

def self.deltas_enabled?
  if Thread.current[:thinking_sphinx_deltas_enabled].nil?
    Thread.current[:thinking_sphinx_deltas_enabled] = (
      ThinkingSphinx::Configuration.environment != "test"
    )
  end
  
  Thread.current[:thinking_sphinx_deltas_enabled]
end

.jruby? ⇒ Boolean 



228
229
230
 
# File 'lib/thinking_sphinx.rb', line 228

def self.jruby?
  defined?(JRUBY_VERSION)
end

.microsoft? ⇒ Boolean 



224
225
226
 
# File 'lib/thinking_sphinx.rb', line 224

def self.microsoft?
  RUBY_PLATFORM =~ /mswin/
end

.mysql? ⇒ Boolean 



232
233
234
235
236
237
 
# File 'lib/thinking_sphinx.rb', line 232

def self.mysql?
  ::ActiveRecord::Base.connection.class.name.demodulize == "MysqlAdapter" ||
  ::ActiveRecord::Base.connection.class.name.demodulize == "MysqlplusAdapter" || (
    jruby? && ::ActiveRecord::Base.connection.config[:adapter] == "jdbcmysql"
  )
end

.pid_active?(pid) ⇒ Boolean 



216
217
218
219
220
221
222
 
# File 'lib/thinking_sphinx.rb', line 216

def self.pid_active?(pid)
  !!Process.kill(0, pid.to_i)
rescue Errno::EPERM => e
  true
rescue Exception => e
  false
end

.remote_sphinx=(value) ⇒ Object

Tells Thinking Sphinx that Sphinx is running on a different machine, and thus it can't reliably guess whether it is running or not (ie: the #sphinx_running? method), and so just assumes it is.

Useful for multi-machine deployments. Set it in your production.rb file.

ThinkingSphinx.remote_sphinx = true



189
190
191
 
# File 'lib/thinking_sphinx.rb', line 189

def self.remote_sphinx=(value)
  Thread.current[:thinking_sphinx_remote_sphinx] = value
end

.remote_sphinx? ⇒ Boolean

An indication of whether Sphinx is running on a remote machine instead of the same machine.



177
178
179
 
# File 'lib/thinking_sphinx.rb', line 177

def self.remote_sphinx?
  Thread.current[:thinking_sphinx_remote_sphinx] ||= false
end

.reset_context! ⇒ Object 



82
83
84
85
86
 
# File 'lib/thinking_sphinx.rb', line 82

def self.reset_context!
  @@sphinx_mutex.synchronize do
    @@context = nil
  end
end

.sphinx_pid ⇒ Object 



208
209
210
211
212
213
214
 
# File 'lib/thinking_sphinx.rb', line 208

def self.sphinx_pid
  if File.exists?(ThinkingSphinx::Configuration.instance.pid_file)
    File.read(ThinkingSphinx::Configuration.instance.pid_file)[/\d+/]
  else
    nil
  end
end

.sphinx_running? ⇒ Boolean

Check if Sphinx is running. If remote_sphinx is set to true (indicating Sphinx is on a different machine), this will always return true, and you will have to handle any connection errors yourself.



197
198
199
 
# File 'lib/thinking_sphinx.rb', line 197

def self.sphinx_running?
  remote_sphinx? || sphinx_running_by_pid?
end

.sphinx_running_by_pid? ⇒ Boolean

Check if Sphinx is actually running, provided the pid is on the same machine as this code.



204
205
206
 
# File 'lib/thinking_sphinx.rb', line 204

def self.sphinx_running_by_pid?
  !!sphinx_pid && pid_active?(sphinx_pid)
end

.suppress_delta_output=(value) ⇒ Object 



155
156
157
 
# File 'lib/thinking_sphinx.rb', line 155

def self.suppress_delta_output=(value)
  Thread.current[:thinking_sphinx_suppress_delta_output] = value
end

.suppress_delta_output? ⇒ Boolean 



151
152
153
 
# File 'lib/thinking_sphinx.rb', line 151

def self.suppress_delta_output?
  Thread.current[:thinking_sphinx_suppress_delta_output] ||= false
end

.unique_id_expression(offset = nil) ⇒ Object 



88
89
90
 
# File 'lib/thinking_sphinx.rb', line 88

def self.unique_id_expression(offset = nil)
  "* #{context.indexed_models.size} + #{offset || 0}"
end

.updates_enabled=(value) ⇒ Object

Enable/disable updates to Sphinx

ThinkingSphinx.updates_enabled = false



147
148
149
 
# File 'lib/thinking_sphinx.rb', line 147

def self.updates_enabled=(value)
  Thread.current[:thinking_sphinx_updates_enabled] = value
end

.updates_enabled? ⇒ Boolean

Check if updates are enabled. True by default, unless within the test environment.



133
134
135
136
137
138
139
140
141
 
# File 'lib/thinking_sphinx.rb', line 133

def self.updates_enabled?
  if Thread.current[:thinking_sphinx_updates_enabled].nil?
    Thread.current[:thinking_sphinx_updates_enabled] = (
      ThinkingSphinx::Configuration.environment != "test"
    )
  end
  
  Thread.current[:thinking_sphinx_updates_enabled]
end

.use_group_by_shortcut? ⇒ Boolean

Checks to see if MySQL will allow simplistic GROUP BY statements. If not, or if not using MySQL, this will return false.



162
163
164
165
166
167
168
169
170
171
172
 
# File 'lib/thinking_sphinx.rb', line 162

def self.use_group_by_shortcut?
  if Thread.current[:thinking_sphinx_use_group_by_shortcut].nil?
    Thread.current[:thinking_sphinx_use_group_by_shortcut] = !!(
      mysql? && ::ActiveRecord::Base.connection.select_all(
        "SELECT @@global.sql_mode, @@session.sql_mode;"
      ).all? { |key,value| value.nil? || value[/ONLY_FULL_GROUP_BY/].nil? }
    )
  end
  
  Thread.current[:thinking_sphinx_use_group_by_shortcut]
end

.version ⇒ String

The current version of Thinking Sphinx.



57
58
59
60
61
 
# File 'lib/thinking_sphinx.rb', line 57

def self.version
  open(File.join(File.dirname(__FILE__), '../VERSION')) { |f|
    f.read.strip
  }
end