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

.delta_by_thinking_sphinx=(value) ⇒ Object

index delta by thinking_sphinx, especially active_record callbacks



136
137
138
 
# File 'lib/thinking_sphinx.rb', line 136

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

.delta_by_thinking_sphinx? ⇒ Boolean 



131
132
133
 
# File 'lib/thinking_sphinx.rb', line 131

def self.delta_by_thinking_sphinx? 
  Thread.current[:delta_by_thinking_sphinx].nil? ? false : Thread.current[:delta_by_thinking_sphinx]
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 



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

def self.jruby?
  defined?(JRUBY_VERSION)
end

.microsoft? ⇒ Boolean 



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

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

.mysql? ⇒ Boolean 



241
242
243
244
245
246
 
# File 'lib/thinking_sphinx.rb', line 241

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 



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

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



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

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.



186
187
188
 
# File 'lib/thinking_sphinx.rb', line 186

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 



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

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.



206
207
208
 
# File 'lib/thinking_sphinx.rb', line 206

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.



213
214
215
 
# File 'lib/thinking_sphinx.rb', line 213

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

.suppress_delta_output=(value) ⇒ Object 



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

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

.suppress_delta_output? ⇒ Boolean 



160
161
162
 
# File 'lib/thinking_sphinx.rb', line 160

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



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

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.



142
143
144
145
146
147
148
149
150
 
# File 'lib/thinking_sphinx.rb', line 142

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.



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

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