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/railtie.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/bundled_search.rb,
lib/thinking_sphinx/search_methods.rb,
lib/thinking_sphinx/action_controller.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/log_subscriber.rb,
lib/thinking_sphinx/active_record/attribute_updates.rb,
lib/thinking_sphinx/active_record/has_many_association.rb,
lib/thinking_sphinx/active_record/has_many_association_with_scopes.rb

Defined Under Namespace

Modules: ActionController, ActiveRecord, Core, Deltas, SearchMethods Classes: AbstractAdapter, Association, Attribute, AutoVersion, BundledSearch, ClassFacet, Configuration, ConnectionError, Context, Excerpter, Facet, FacetSearch, Field, Index, Join, MysqlAdapter, PostgreSQLAdapter, Property, Railtie, Search, Source, SphinxError, 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
@@define_indexes = 
true
@@deltas_enabled = 
nil
@@updates_enabled = 
nil
@@suppress_delta_output = 
false
@@remote_sphinx = 
false
@@use_group_by_shortcut = 
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 



86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/thinking_sphinx.rb', line 86

def self.context
  if @@context.nil?
    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



119
120
121
122
123
 
# File 'lib/thinking_sphinx.rb', line 119

def self.define_indexes=(value)
  mutex.synchronize do
    @@define_indexes = value
  end
end

.define_indexes? ⇒ Boolean

Check if index definition is disabled.

Returns:

  • (Boolean) 


111
112
113
 
# File 'lib/thinking_sphinx.rb', line 111

def self.define_indexes?
  @@define_indexes
end

.deltas_enabled=(value) ⇒ Object

Enable/disable delta indexing.

ThinkingSphinx.deltas_enabled = false



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

def self.deltas_enabled=(value)
  mutex.synchronize do
    @@deltas_enabled = value
  end
end

.deltas_enabled? ⇒ Boolean

Check if delta indexing is enabled/disabled.

Returns:

  • (Boolean) 


127
128
129
130
131
132
133
134
135
136
137
138
139
 
# File 'lib/thinking_sphinx.rb', line 127

def self.deltas_enabled?
  if @@deltas_enabled.nil?
    mutex.synchronize do
      if @@deltas_enabled.nil?
        @@deltas_enabled = (
          ThinkingSphinx::Configuration.environment != "test"
        )
      end
    end
  end
  
  @@deltas_enabled && !deltas_suspended?
end

.deltas_suspended=(value) ⇒ Object

Suspend/resume delta indexing.

ThinkingSphinx.deltas_suspended = false



165
166
167
 
# File 'lib/thinking_sphinx.rb', line 165

def self.deltas_suspended=(value)
  Thread.current[:thinking_sphinx_deltas_suspended] = value
end

.deltas_suspended? ⇒ Boolean

Check if delta indexing is suspended.

Returns:

  • (Boolean) 


153
154
155
156
157
158
159
 
# File 'lib/thinking_sphinx.rb', line 153

def self.deltas_suspended?
  if Thread.current[:thinking_sphinx_deltas_suspended].nil?
    Thread.current[:thinking_sphinx_deltas_suspended] = false
  end
  
  Thread.current[:thinking_sphinx_deltas_suspended]
end

.jruby? ⇒ Boolean

Returns:

  • (Boolean) 


289
290
291
 
# File 'lib/thinking_sphinx.rb', line 289

def self.jruby?
  defined?(JRUBY_VERSION)
end

.microsoft? ⇒ Boolean

Returns:

  • (Boolean) 


285
286
287
 
# File 'lib/thinking_sphinx.rb', line 285

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

.mutex ⇒ Object 



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

def self.mutex
  @@sphinx_mutex
end

.mysql? ⇒ Boolean

Returns:

  • (Boolean) 


293
294
295
296
297
298
 
# File 'lib/thinking_sphinx.rb', line 293

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) 


277
278
279
280
281
282
283
 
# File 'lib/thinking_sphinx.rb', line 277

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



248
249
250
251
252
 
# File 'lib/thinking_sphinx.rb', line 248

def self.remote_sphinx=(value)
  mutex.synchronize do
    @@remote_sphinx = value
  end
end

.remote_sphinx? ⇒ Boolean

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

Returns:

  • (Boolean) 


236
237
238
 
# File 'lib/thinking_sphinx.rb', line 236

def self.remote_sphinx?
  @@remote_sphinx
end

.reset_context!(context = nil) ⇒ Object 



99
100
101
102
103
 
# File 'lib/thinking_sphinx.rb', line 99

def self.reset_context!(context = nil)
  mutex.synchronize do
    @@context = context
  end
end

.reset_use_group_by_shortcut ⇒ Object 



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

def self.reset_use_group_by_shortcut
  mutex.synchronize do
    @@use_group_by_shortcut = nil
  end
end

.sphinx_pid ⇒ Object 



269
270
271
272
273
274
275
 
# File 'lib/thinking_sphinx.rb', line 269

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) 


258
259
260
 
# File 'lib/thinking_sphinx.rb', line 258

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) 


265
266
267
 
# File 'lib/thinking_sphinx.rb', line 265

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

.suppress_delta_output=(value) ⇒ Object 



200
201
202
203
204
 
# File 'lib/thinking_sphinx.rb', line 200

def self.suppress_delta_output=(value)
  mutex.synchronize do
    @@suppress_delta_output = value
  end
end

.suppress_delta_output? ⇒ Boolean

Returns:

  • (Boolean) 


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

def self.suppress_delta_output?
  @@suppress_delta_output
end

.unique_id_expression(adapter, offset = nil) ⇒ Object 



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

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

.updates_enabled=(value) ⇒ Object

Enable/disable updates to Sphinx

ThinkingSphinx.updates_enabled = false



190
191
192
193
194
 
# File 'lib/thinking_sphinx.rb', line 190

def self.updates_enabled=(value)
  mutex.synchronize do
    @@updates_enabled = value
  end
end

.updates_enabled? ⇒ Boolean

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

Returns:

  • (Boolean) 


172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/thinking_sphinx.rb', line 172

def self.updates_enabled?
  if @@updates_enabled.nil?
    mutex.synchronize do
      if @@updates_enabled.nil?
        @@updates_enabled = (
          ThinkingSphinx::Configuration.environment != "test"
        )
      end
    end
  end
  
  @@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) 


209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
 
# File 'lib/thinking_sphinx.rb', line 209

def self.use_group_by_shortcut?
  if @@use_group_by_shortcut.nil?
    mutex.synchronize do
      if @@use_group_by_shortcut.nil?
        @@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
    end
  end
  
  @@use_group_by_shortcut
end

.version ⇒ String

The current version of Thinking Sphinx.

Returns:

  • (String) —

    The version number as a string



64
65
66
67
68
 
# File 'lib/thinking_sphinx.rb', line 64

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