Module: ThinkingSphinx

Extended by:
SearchMethods::ClassMethods
Defined in:
lib/thinking_sphinx.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, MetaClass, MysqlQuotedTableName, SearchMethods Classes: AbstractAdapter, Association, Attribute, AutoVersion, ClassFacet, Configuration, ConnectionError, Context, Excerpter, Facet, FacetSearch, Field, Index, 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.

Returns:

  • (Boolean) 


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.

Returns:

  • (Boolean) 


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

Returns:

  • (Boolean) 


226
227
228
 
# File 'lib/thinking_sphinx.rb', line 226

def self.jruby?
  defined?(JRUBY_VERSION)
end

.microsoft? ⇒ Boolean

Returns:

  • (Boolean) 


222
223
224
 
# File 'lib/thinking_sphinx.rb', line 222

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

.mysql? ⇒ Boolean

Returns:

  • (Boolean) 


230
231
232
233
234
235
 
# File 'lib/thinking_sphinx.rb', line 230

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

Returns:

  • (Boolean) 


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

def self.pid_active?(pid)
  !!Process.kill(0, pid.to_i)
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.

Returns:

  • (Boolean) 


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.

Returns:

  • (Boolean) 


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.

Returns:

  • (Boolean) 


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

Returns:

  • (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.

Returns:

  • (Boolean) 


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.

Returns:

  • (Boolean) 


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.

Returns:

  • (String) —

    The version number as a string



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