josh_cutler-thinking-sphinx 1.3.17

Sign up to get free protection for your applications and to get access to all the features.
Files changed (158) hide show
  1. data/LICENCE +20 -0
  2. data/README.textile +167 -0
  3. data/VERSION +1 -0
  4. data/features/abstract_inheritance.feature +10 -0
  5. data/features/alternate_primary_key.feature +27 -0
  6. data/features/attribute_transformation.feature +22 -0
  7. data/features/attribute_updates.feature +77 -0
  8. data/features/deleting_instances.feature +67 -0
  9. data/features/direct_attributes.feature +11 -0
  10. data/features/excerpts.feature +13 -0
  11. data/features/extensible_delta_indexing.feature +9 -0
  12. data/features/facets.feature +82 -0
  13. data/features/facets_across_model.feature +29 -0
  14. data/features/handling_edits.feature +92 -0
  15. data/features/retry_stale_indexes.feature +24 -0
  16. data/features/searching_across_models.feature +20 -0
  17. data/features/searching_by_index.feature +40 -0
  18. data/features/searching_by_model.feature +175 -0
  19. data/features/searching_with_find_arguments.feature +56 -0
  20. data/features/sphinx_detection.feature +25 -0
  21. data/features/sphinx_scopes.feature +42 -0
  22. data/features/step_definitions/alpha_steps.rb +16 -0
  23. data/features/step_definitions/beta_steps.rb +7 -0
  24. data/features/step_definitions/common_steps.rb +193 -0
  25. data/features/step_definitions/extensible_delta_indexing_steps.rb +7 -0
  26. data/features/step_definitions/facet_steps.rb +96 -0
  27. data/features/step_definitions/find_arguments_steps.rb +36 -0
  28. data/features/step_definitions/gamma_steps.rb +15 -0
  29. data/features/step_definitions/scope_steps.rb +15 -0
  30. data/features/step_definitions/search_steps.rb +89 -0
  31. data/features/step_definitions/sphinx_steps.rb +35 -0
  32. data/features/sti_searching.feature +19 -0
  33. data/features/support/env.rb +21 -0
  34. data/features/support/lib/generic_delta_handler.rb +8 -0
  35. data/features/thinking_sphinx/database.example.yml +3 -0
  36. data/features/thinking_sphinx/db/fixtures/alphas.rb +10 -0
  37. data/features/thinking_sphinx/db/fixtures/authors.rb +1 -0
  38. data/features/thinking_sphinx/db/fixtures/betas.rb +11 -0
  39. data/features/thinking_sphinx/db/fixtures/boxes.rb +9 -0
  40. data/features/thinking_sphinx/db/fixtures/categories.rb +1 -0
  41. data/features/thinking_sphinx/db/fixtures/cats.rb +3 -0
  42. data/features/thinking_sphinx/db/fixtures/comments.rb +24 -0
  43. data/features/thinking_sphinx/db/fixtures/developers.rb +31 -0
  44. data/features/thinking_sphinx/db/fixtures/dogs.rb +3 -0
  45. data/features/thinking_sphinx/db/fixtures/extensible_betas.rb +10 -0
  46. data/features/thinking_sphinx/db/fixtures/foxes.rb +3 -0
  47. data/features/thinking_sphinx/db/fixtures/gammas.rb +10 -0
  48. data/features/thinking_sphinx/db/fixtures/music.rb +4 -0
  49. data/features/thinking_sphinx/db/fixtures/people.rb +1001 -0
  50. data/features/thinking_sphinx/db/fixtures/posts.rb +6 -0
  51. data/features/thinking_sphinx/db/fixtures/robots.rb +14 -0
  52. data/features/thinking_sphinx/db/fixtures/tags.rb +27 -0
  53. data/features/thinking_sphinx/db/migrations/create_alphas.rb +8 -0
  54. data/features/thinking_sphinx/db/migrations/create_animals.rb +5 -0
  55. data/features/thinking_sphinx/db/migrations/create_authors.rb +3 -0
  56. data/features/thinking_sphinx/db/migrations/create_authors_posts.rb +6 -0
  57. data/features/thinking_sphinx/db/migrations/create_betas.rb +5 -0
  58. data/features/thinking_sphinx/db/migrations/create_boxes.rb +5 -0
  59. data/features/thinking_sphinx/db/migrations/create_categories.rb +3 -0
  60. data/features/thinking_sphinx/db/migrations/create_comments.rb +10 -0
  61. data/features/thinking_sphinx/db/migrations/create_developers.rb +7 -0
  62. data/features/thinking_sphinx/db/migrations/create_extensible_betas.rb +5 -0
  63. data/features/thinking_sphinx/db/migrations/create_gammas.rb +3 -0
  64. data/features/thinking_sphinx/db/migrations/create_genres.rb +3 -0
  65. data/features/thinking_sphinx/db/migrations/create_music.rb +6 -0
  66. data/features/thinking_sphinx/db/migrations/create_people.rb +13 -0
  67. data/features/thinking_sphinx/db/migrations/create_posts.rb +5 -0
  68. data/features/thinking_sphinx/db/migrations/create_robots.rb +4 -0
  69. data/features/thinking_sphinx/db/migrations/create_taggings.rb +5 -0
  70. data/features/thinking_sphinx/db/migrations/create_tags.rb +4 -0
  71. data/features/thinking_sphinx/models/alpha.rb +22 -0
  72. data/features/thinking_sphinx/models/animal.rb +5 -0
  73. data/features/thinking_sphinx/models/author.rb +3 -0
  74. data/features/thinking_sphinx/models/beta.rb +8 -0
  75. data/features/thinking_sphinx/models/box.rb +8 -0
  76. data/features/thinking_sphinx/models/cat.rb +3 -0
  77. data/features/thinking_sphinx/models/category.rb +4 -0
  78. data/features/thinking_sphinx/models/comment.rb +10 -0
  79. data/features/thinking_sphinx/models/developer.rb +16 -0
  80. data/features/thinking_sphinx/models/dog.rb +3 -0
  81. data/features/thinking_sphinx/models/extensible_beta.rb +9 -0
  82. data/features/thinking_sphinx/models/fox.rb +5 -0
  83. data/features/thinking_sphinx/models/gamma.rb +5 -0
  84. data/features/thinking_sphinx/models/genre.rb +3 -0
  85. data/features/thinking_sphinx/models/medium.rb +5 -0
  86. data/features/thinking_sphinx/models/music.rb +8 -0
  87. data/features/thinking_sphinx/models/person.rb +23 -0
  88. data/features/thinking_sphinx/models/post.rb +21 -0
  89. data/features/thinking_sphinx/models/robot.rb +12 -0
  90. data/features/thinking_sphinx/models/tag.rb +3 -0
  91. data/features/thinking_sphinx/models/tagging.rb +4 -0
  92. data/lib/cucumber/thinking_sphinx/external_world.rb +8 -0
  93. data/lib/cucumber/thinking_sphinx/internal_world.rb +126 -0
  94. data/lib/cucumber/thinking_sphinx/sql_logger.rb +20 -0
  95. data/lib/thinking_sphinx.rb +242 -0
  96. data/lib/thinking_sphinx/active_record.rb +380 -0
  97. data/lib/thinking_sphinx/active_record/attribute_updates.rb +50 -0
  98. data/lib/thinking_sphinx/active_record/delta.rb +61 -0
  99. data/lib/thinking_sphinx/active_record/has_many_association.rb +51 -0
  100. data/lib/thinking_sphinx/active_record/scopes.rb +75 -0
  101. data/lib/thinking_sphinx/adapters/abstract_adapter.rb +46 -0
  102. data/lib/thinking_sphinx/adapters/mysql_adapter.rb +58 -0
  103. data/lib/thinking_sphinx/adapters/postgresql_adapter.rb +147 -0
  104. data/lib/thinking_sphinx/association.rb +164 -0
  105. data/lib/thinking_sphinx/attribute.rb +390 -0
  106. data/lib/thinking_sphinx/auto_version.rb +22 -0
  107. data/lib/thinking_sphinx/class_facet.rb +15 -0
  108. data/lib/thinking_sphinx/configuration.rb +292 -0
  109. data/lib/thinking_sphinx/context.rb +74 -0
  110. data/lib/thinking_sphinx/core/array.rb +7 -0
  111. data/lib/thinking_sphinx/core/string.rb +15 -0
  112. data/lib/thinking_sphinx/deltas.rb +28 -0
  113. data/lib/thinking_sphinx/deltas/default_delta.rb +62 -0
  114. data/lib/thinking_sphinx/deploy/capistrano.rb +100 -0
  115. data/lib/thinking_sphinx/excerpter.rb +22 -0
  116. data/lib/thinking_sphinx/facet.rb +125 -0
  117. data/lib/thinking_sphinx/facet_search.rb +136 -0
  118. data/lib/thinking_sphinx/field.rb +80 -0
  119. data/lib/thinking_sphinx/index.rb +157 -0
  120. data/lib/thinking_sphinx/index/builder.rb +302 -0
  121. data/lib/thinking_sphinx/index/faux_column.rb +118 -0
  122. data/lib/thinking_sphinx/property.rb +168 -0
  123. data/lib/thinking_sphinx/rails_additions.rb +150 -0
  124. data/lib/thinking_sphinx/search.rb +785 -0
  125. data/lib/thinking_sphinx/search_methods.rb +439 -0
  126. data/lib/thinking_sphinx/source.rb +159 -0
  127. data/lib/thinking_sphinx/source/internal_properties.rb +46 -0
  128. data/lib/thinking_sphinx/source/sql.rb +130 -0
  129. data/lib/thinking_sphinx/tasks.rb +121 -0
  130. data/lib/thinking_sphinx/test.rb +52 -0
  131. data/rails/init.rb +16 -0
  132. data/spec/thinking_sphinx/active_record/delta_spec.rb +128 -0
  133. data/spec/thinking_sphinx/active_record/has_many_association_spec.rb +71 -0
  134. data/spec/thinking_sphinx/active_record/scopes_spec.rb +177 -0
  135. data/spec/thinking_sphinx/active_record_spec.rb +618 -0
  136. data/spec/thinking_sphinx/association_spec.rb +239 -0
  137. data/spec/thinking_sphinx/attribute_spec.rb +548 -0
  138. data/spec/thinking_sphinx/auto_version_spec.rb +39 -0
  139. data/spec/thinking_sphinx/configuration_spec.rb +271 -0
  140. data/spec/thinking_sphinx/context_spec.rb +126 -0
  141. data/spec/thinking_sphinx/core/array_spec.rb +9 -0
  142. data/spec/thinking_sphinx/core/string_spec.rb +9 -0
  143. data/spec/thinking_sphinx/excerpter_spec.rb +49 -0
  144. data/spec/thinking_sphinx/facet_search_spec.rb +176 -0
  145. data/spec/thinking_sphinx/facet_spec.rb +333 -0
  146. data/spec/thinking_sphinx/field_spec.rb +113 -0
  147. data/spec/thinking_sphinx/index/builder_spec.rb +495 -0
  148. data/spec/thinking_sphinx/index/faux_column_spec.rb +36 -0
  149. data/spec/thinking_sphinx/index_spec.rb +183 -0
  150. data/spec/thinking_sphinx/rails_additions_spec.rb +203 -0
  151. data/spec/thinking_sphinx/search_methods_spec.rb +152 -0
  152. data/spec/thinking_sphinx/search_spec.rb +1206 -0
  153. data/spec/thinking_sphinx/source_spec.rb +243 -0
  154. data/spec/thinking_sphinx_spec.rb +204 -0
  155. data/tasks/distribution.rb +46 -0
  156. data/tasks/rails.rake +1 -0
  157. data/tasks/testing.rb +76 -0
  158. metadata +475 -0
@@ -0,0 +1,439 @@
1
+ module ThinkingSphinx
2
+ module SearchMethods
3
+ def self.included(base)
4
+ base.class_eval do
5
+ extend ThinkingSphinx::SearchMethods::ClassMethods
6
+ end
7
+ end
8
+
9
+ module ClassMethods
10
+ def search_context
11
+ # Comparing to name string to avoid class inheritance complications
12
+ case self.class.name
13
+ when 'Class'
14
+ self
15
+ else
16
+ nil
17
+ end
18
+ end
19
+
20
+ # Searches through the Sphinx indexes for relevant matches. There's
21
+ # various ways to search, sort, group and filter - which are covered
22
+ # below.
23
+ #
24
+ # Also, if you have WillPaginate installed, the search method can be used
25
+ # just like paginate. The same parameters - :page and :per_page - work as
26
+ # expected, and the returned result set can be used by the will_paginate
27
+ # helper.
28
+ #
29
+ # == Basic Searching
30
+ #
31
+ # The simplest way of searching is straight text.
32
+ #
33
+ # ThinkingSphinx.search "pat"
34
+ # ThinkingSphinx.search "google"
35
+ # User.search "pat", :page => (params[:page] || 1)
36
+ # Article.search "relevant news issue of the day"
37
+ #
38
+ # If you specify :include, like in an #find call, this will be respected
39
+ # when loading the relevant models from the search results.
40
+ #
41
+ # User.search "pat", :include => :posts
42
+ #
43
+ # == Match Modes
44
+ #
45
+ # Sphinx supports 5 different matching modes. By default Thinking Sphinx
46
+ # uses :all, which unsurprisingly requires all the supplied search terms
47
+ # to match a result.
48
+ #
49
+ # Alternative modes include:
50
+ #
51
+ # User.search "pat allan", :match_mode => :any
52
+ # User.search "pat allan", :match_mode => :phrase
53
+ # User.search "pat | allan", :match_mode => :boolean
54
+ # User.search "@name pat | @username pat", :match_mode => :extended
55
+ #
56
+ # Any will find results with any of the search terms. Phrase treats the
57
+ # search terms a single phrase instead of individual words. Boolean and
58
+ # extended allow for more complex query syntax, refer to the sphinx
59
+ # documentation for further details.
60
+ #
61
+ # == Weighting
62
+ #
63
+ # Sphinx has support for weighting, where matches in one field can be
64
+ # considered more important than in another. Weights are integers, with 1
65
+ # as the default. They can be set per-search like this:
66
+ #
67
+ # User.search "pat allan", :field_weights => { :alias => 4, :aka => 2 }
68
+ #
69
+ # If you're searching multiple models, you can set per-index weights:
70
+ #
71
+ # ThinkingSphinx.search "pat", :index_weights => { User => 10 }
72
+ #
73
+ # See http://sphinxsearch.com/doc.html#weighting for further details.
74
+ #
75
+ # == Searching by Fields
76
+ #
77
+ # If you want to step it up a level, you can limit your search terms to
78
+ # specific fields:
79
+ #
80
+ # User.search :conditions => {:name => "pat"}
81
+ #
82
+ # This uses Sphinx's extended match mode, unless you specify a different
83
+ # match mode explicitly (but then this way of searching won't work). Also
84
+ # note that you don't need to put in a search string.
85
+ #
86
+ # == Searching by Attributes
87
+ #
88
+ # Also known as filters, you can limit your searches to documents that
89
+ # have specific values for their attributes. There are three ways to do
90
+ # this. The first two techniques work in all scenarios - using the :with
91
+ # or :with_all options.
92
+ #
93
+ # ThinkingSphinx.search :with => {:tag_ids => 10}
94
+ # ThinkingSphinx.search :with => {:tag_ids => [10,12]}
95
+ # ThinkingSphinx.search :with_all => {:tag_ids => [10,12]}
96
+ #
97
+ # The first :with search will match records with a tag_id attribute of 10.
98
+ # The second :with will match records with a tag_id attribute of 10 OR 12.
99
+ # If you need to find records that are tagged with ids 10 AND 12, you
100
+ # will need to use the :with_all search parameter. This is particuarly
101
+ # useful in conjunction with Multi Value Attributes (MVAs).
102
+ #
103
+ # The third filtering technique is only viable if you're searching with a
104
+ # specific model (not multi-model searching). With a single model,
105
+ # Thinking Sphinx can figure out what attributes and fields are available,
106
+ # so you can put it all in the :conditions hash, and it will sort it out.
107
+ #
108
+ # Node.search :conditions => {:parent_id => 10}
109
+ #
110
+ # Filters can be single values, arrays of values, or ranges.
111
+ #
112
+ # Article.search "East Timor", :conditions => {:rating => 3..5}
113
+ #
114
+ # == Excluding by Attributes
115
+ #
116
+ # Sphinx also supports negative filtering - where the filters are of
117
+ # attribute values to exclude. This is done with the :without option:
118
+ #
119
+ # User.search :without => {:role_id => 1}
120
+ #
121
+ # == Excluding by Primary Key
122
+ #
123
+ # There is a shortcut to exclude records by their ActiveRecord primary
124
+ # key:
125
+ #
126
+ # User.search :without_ids => 1
127
+ #
128
+ # Pass an array or a single value.
129
+ #
130
+ # The primary key must be an integer as a negative filter is used. Note
131
+ # that for multi-model search, an id may occur in more than one model.
132
+ #
133
+ # == Infix (Star) Searching
134
+ #
135
+ # Enable infix searching by something like this in config/sphinx.yml:
136
+ #
137
+ # development:
138
+ # enable_star: 1
139
+ # min_infix_len: 2
140
+ #
141
+ # Note that this will make indexing take longer.
142
+ #
143
+ # With those settings (and after reindexing), wildcard asterisks can be
144
+ # used in queries:
145
+ #
146
+ # Location.search "*elbourn*"
147
+ #
148
+ # To automatically add asterisks around every token (but not operators),
149
+ # pass the :star option:
150
+ #
151
+ # Location.search "elbourn -ustrali", :star => true,
152
+ # :match_mode => :boolean
153
+ #
154
+ # This would become "*elbourn* -*ustrali*". The :star option only adds the
155
+ # asterisks. You need to make the config/sphinx.yml changes yourself.
156
+ #
157
+ # By default, the tokens are assumed to match the regular expression
158
+ # /\w\+/u\+. If you've modified the charset_table, pass another regular
159
+ # expression, e.g.
160
+ #
161
+ # User.search("oo@bar.c", :star => /[\w@.]+/u)
162
+ #
163
+ # to search for "*oo@bar.c*" and not "*oo*@*bar*.*c*".
164
+ #
165
+ # == Sorting
166
+ #
167
+ # Sphinx can only sort by attributes, so generally you will need to avoid
168
+ # using field names in your :order option. However, if you're searching
169
+ # on a single model, and have specified some fields as sortable, you can
170
+ # use those field names and Thinking Sphinx will interpret accordingly.
171
+ # Remember: this will only happen for single-model searches, and only
172
+ # through the :order option.
173
+ #
174
+ # Location.search "Melbourne", :order => :state
175
+ # User.search :conditions => {:role_id => 2}, :order => "name ASC"
176
+ #
177
+ # Keep in mind that if you use a string, you *must* specify the direction
178
+ # (ASC or DESC) else Sphinx won't return any results. If you use a symbol
179
+ # then Thinking Sphinx assumes ASC, but if you wish to state otherwise,
180
+ # use the :sort_mode option:
181
+ #
182
+ # Location.search "Melbourne", :order => :state, :sort_mode => :desc
183
+ #
184
+ # Of course, there are other sort modes - check out the Sphinx
185
+ # documentation[http://sphinxsearch.com/doc.html] for that level of
186
+ # detail though.
187
+ #
188
+ # If desired, you can sort by a column in your model instead of a sphinx
189
+ # field or attribute. This sort only applies to the current page, so is
190
+ # most useful when performing a search with a single page of results.
191
+ #
192
+ # User.search("pat", :sql_order => "name")
193
+ #
194
+ # == Grouping
195
+ #
196
+ # For this you can use the group_by, group_clause and group_function
197
+ # options - which are all directly linked to Sphinx's expectations. No
198
+ # magic from Thinking Sphinx. It can get a little tricky, so make sure
199
+ # you read all the relevant
200
+ # documentation[http://sphinxsearch.com/doc.html#clustering] first.
201
+ #
202
+ # Grouping is done via three parameters within the options hash
203
+ # * <tt>:group_function</tt> determines the way grouping is done
204
+ # * <tt>:group_by</tt> determines the field which is used for grouping
205
+ # * <tt>:group_clause</tt> determines the sorting order
206
+ #
207
+ # As a convenience, you can also use
208
+ # * <tt>:group</tt>
209
+ # which sets :group_by and defaults to :group_function of :attr
210
+ #
211
+ # === group_function
212
+ #
213
+ # Valid values for :group_function are
214
+ # * <tt>:day</tt>, <tt>:week</tt>, <tt>:month</tt>, <tt>:year</tt> - Grouping is done by the respective timeframes.
215
+ # * <tt>:attr</tt>, <tt>:attrpair</tt> - Grouping is done by the specified attributes(s)
216
+ #
217
+ # === group_by
218
+ #
219
+ # This parameter denotes the field by which grouping is done. Note that
220
+ # the specified field must be a sphinx attribute or index.
221
+ #
222
+ # === group_clause
223
+ #
224
+ # This determines the sorting order of the groups. In a grouping search,
225
+ # the matches within a group will sorted by the <tt>:sort_mode</tt> and
226
+ # <tt>:order</tt> parameters. The group matches themselves however, will
227
+ # be sorted by <tt>:group_clause</tt>.
228
+ #
229
+ # The syntax for this is the same as an order parameter in extended sort
230
+ # mode. Namely, you can specify an SQL-like sort expression with up to 5
231
+ # attributes (including internal attributes), eg: "@relevance DESC, price
232
+ # ASC, @id DESC"
233
+ #
234
+ # === Grouping by timestamp
235
+ #
236
+ # Timestamp grouping groups off items by the day, week, month or year of
237
+ # the attribute given. In order to do this you need to define a timestamp
238
+ # attribute, which pretty much looks like the standard defintion for any
239
+ # attribute.
240
+ #
241
+ # define_index do
242
+ # #
243
+ # # All your other stuff
244
+ # #
245
+ # has :created_at
246
+ # end
247
+ #
248
+ # When you need to fire off your search, it'll go something to the tune of
249
+ #
250
+ # Fruit.search "apricot", :group_function => :day,
251
+ # :group_by => 'created_at'
252
+ #
253
+ # The <tt>@groupby</tt> special attribute will contain the date for that
254
+ # group. Depending on the <tt>:group_function</tt> parameter, the date
255
+ # format will be:
256
+ #
257
+ # * <tt>:day</tt> - YYYYMMDD
258
+ # * <tt>:week</tt> - YYYYNNN (NNN is the first day of the week in question,
259
+ # counting from the start of the year )
260
+ # * <tt>:month</tt> - YYYYMM
261
+ # * <tt>:year</tt> - YYYY
262
+ #
263
+ # === Grouping by attribute
264
+ #
265
+ # The syntax is the same as grouping by timestamp, except for the fact
266
+ # that the <tt>:group_function</tt> parameter is changed.
267
+ #
268
+ # Fruit.search "apricot", :group_function => :attr, :group_by => 'size'
269
+ #
270
+ # == Geo/Location Searching
271
+ #
272
+ # Sphinx - and therefore Thinking Sphinx - has the facility to search
273
+ # around a geographical point, using a given latitude and longitude. To
274
+ # take advantage of this, you will need to have both of those values in
275
+ # attributes. To search with that point, you can then use one of the
276
+ # following syntax examples:
277
+ #
278
+ # Address.search "Melbourne", :geo => [1.4, -2.217],
279
+ # :order => "@geodist asc"
280
+ # Address.search "Australia", :geo => [-0.55, 3.108],
281
+ # :order => "@geodist asc" :latitude_attr => "latit",
282
+ # :longitude_attr => "longit"
283
+ #
284
+ # The first example applies when your latitude and longitude attributes
285
+ # are named any of lat, latitude, lon, long or longitude. If that's not
286
+ # the case, you will need to explicitly state them in your search, _or_
287
+ # you can do so in your model:
288
+ #
289
+ # define_index do
290
+ # has :latit # Float column, stored in radians
291
+ # has :longit # Float column, stored in radians
292
+ #
293
+ # set_property :latitude_attr => "latit"
294
+ # set_property :longitude_attr => "longit"
295
+ # end
296
+ #
297
+ # Now, geo-location searching really only has an affect if you have a
298
+ # filter, sort or grouping clause related to it - otherwise it's just a
299
+ # normal search, and _will not_ return a distance value otherwise. To
300
+ # make use of the positioning difference, use the special attribute
301
+ # "@geodist" in any of your filters or sorting or grouping clauses.
302
+ #
303
+ # And don't forget - both the latitude and longitude you use in your
304
+ # search, and the values in your indexes, need to be stored as a float in
305
+ # radians, _not_ degrees. Keep in mind that if you do this conversion in
306
+ # SQL you will need to explicitly declare a column type of :float.
307
+ #
308
+ # define_index do
309
+ # has 'RADIANS(lat)', :as => :lat, :type => :float
310
+ # # ...
311
+ # end
312
+ #
313
+ # Once you've got your results set, you can access the distances as
314
+ # follows:
315
+ #
316
+ # @results.each_with_geodist do |result, distance|
317
+ # # ...
318
+ # end
319
+ #
320
+ # The distance value is returned as a float, representing the distance in
321
+ # metres.
322
+ #
323
+ # == Filtering by custom attributes
324
+ #
325
+ # Do note that this applies only to sphinx 0.9.9
326
+ #
327
+ # Should you find yourself in desperate need of a filter that involves
328
+ # selecting either one of multiple conditions, one solution could be
329
+ # provided by the :sphinx_select option within the search.
330
+ # This handles which fields are selected by sphinx from its store.
331
+ #
332
+ # The default value is "*", and you can add custom fields using syntax
333
+ # similar to sql:
334
+ #
335
+ # Flower.search "foo",
336
+ # :sphinx_select => "*, petals < 1 or color = 2 as grass"
337
+ #
338
+ # This will add the 'grass' attribute, which will now be usable in your
339
+ # filters.
340
+ #
341
+ # == Handling a Stale Index
342
+ #
343
+ # Especially if you don't use delta indexing, you risk having records in
344
+ # the Sphinx index that are no longer in the database. By default, those
345
+ # will simply come back as nils:
346
+ #
347
+ # >> pat_user.delete
348
+ # >> User.search("pat")
349
+ # Sphinx Result: [1,2]
350
+ # => [nil, <#User id: 2>]
351
+ #
352
+ # (If you search across multiple models, you'll get
353
+ # ActiveRecord::RecordNotFound.)
354
+ #
355
+ # You can simply Array#compact these results or handle the nils in some
356
+ # other way, but Sphinx will still report two results, and the missing
357
+ # records may upset your layout.
358
+ #
359
+ # If you pass :retry_stale => true to a single-model search, missing
360
+ # records will cause Thinking Sphinx to retry the query but excluding
361
+ # those records. Since search is paginated, the new search could
362
+ # potentially include missing records as well, so by default Thinking
363
+ # Sphinx will retry three times. Pass :retry_stale => 5 to retry five
364
+ # times, and so on. If there are still missing ids on the last retry, they
365
+ # are shown as nils.
366
+ #
367
+ def search(*args)
368
+ ThinkingSphinx::Search.new *search_options(args)
369
+ end
370
+
371
+ # Searches for results that match the parameters provided. Will only
372
+ # return the ids for the matching objects. See #search for syntax
373
+ # examples.
374
+ #
375
+ # Note that this only searches the Sphinx index, with no ActiveRecord
376
+ # queries. Thus, if your index is not in sync with the database, this
377
+ # method may return ids that no longer exist there.
378
+ #
379
+ def search_for_ids(*args)
380
+ ThinkingSphinx::Search.new *search_options(args, :ids_only => true)
381
+ end
382
+
383
+ # Checks if a document with the given id exists within a specific index.
384
+ # Expected parameters:
385
+ #
386
+ # - ID of the document
387
+ # - Index to check within
388
+ # - Options hash (defaults to {})
389
+ #
390
+ # Example:
391
+ #
392
+ # ThinkingSphinx.search_for_id(10, "user_core", :class => User)
393
+ #
394
+ def search_for_id(id, index, options = {})
395
+ ThinkingSphinx::Search.new(
396
+ *search_options([],
397
+ :ids_only => true,
398
+ :index => index,
399
+ :id_range => id..id
400
+ )
401
+ ).any?
402
+ end
403
+
404
+ def count(*args)
405
+ search_context ? super : search_count(*args)
406
+ end
407
+
408
+ def search_count(*args)
409
+ search = ThinkingSphinx::Search.new(
410
+ *search_options(args, :ids_only => true)
411
+ )
412
+ search.first # forces the query
413
+ search.total_entries
414
+ end
415
+
416
+ # Model.facets *args
417
+ # ThinkingSphinx.facets *args
418
+ # ThinkingSphinx.facets *args, :all_facets => true
419
+ # ThinkingSphinx.facets *args, :class_facet => false
420
+ #
421
+ def facets(*args)
422
+ ThinkingSphinx::FacetSearch.new *search_options(args)
423
+ end
424
+
425
+ private
426
+
427
+ def search_options(args, options = {})
428
+ options = args.extract_options!.merge(options)
429
+ options[:classes] ||= classes_option
430
+ args << options
431
+ end
432
+
433
+ def classes_option
434
+ classes_option = [search_context].compact
435
+ classes_option.empty? ? nil : classes_option
436
+ end
437
+ end
438
+ end
439
+ end
@@ -0,0 +1,159 @@
1
+ require 'thinking_sphinx/source/internal_properties'
2
+ require 'thinking_sphinx/source/sql'
3
+
4
+ module ThinkingSphinx
5
+ class Source
6
+ include ThinkingSphinx::Source::InternalProperties
7
+ include ThinkingSphinx::Source::SQL
8
+
9
+ attr_accessor :model, :fields, :attributes, :joins, :conditions, :groupings,
10
+ :options
11
+ attr_reader :base, :index, :database_configuration
12
+
13
+ def initialize(index, options = {})
14
+ @index = index
15
+ @model = index.model
16
+ @fields = []
17
+ @attributes = []
18
+ @joins = []
19
+ @conditions = []
20
+ @groupings = []
21
+ @options = options
22
+ @associations = {}
23
+ @database_configuration = @model.connection.
24
+ instance_variable_get(:@config).clone
25
+
26
+ @base = ::ActiveRecord::Associations::ClassMethods::JoinDependency.new(
27
+ @model, [], nil
28
+ )
29
+
30
+ unless @model.descends_from_active_record?
31
+ stored_class = @model.store_full_sti_class ? @model.name : @model.name.demodulize
32
+ @conditions << "#{@model.quoted_table_name}.#{quote_column(@model.inheritance_column)} = '#{stored_class}'"
33
+ end
34
+
35
+ add_internal_attributes_and_facets
36
+ end
37
+
38
+ def name
39
+ index.name
40
+ end
41
+
42
+ def to_riddle_for_core(offset, position)
43
+ source = Riddle::Configuration::SQLSource.new(
44
+ "#{index.core_name}_#{position}", adapter.sphinx_identifier
45
+ )
46
+
47
+ set_source_database_settings source
48
+ set_source_attributes source, offset
49
+ set_source_settings source
50
+ set_source_sql source, offset
51
+
52
+ source
53
+ end
54
+
55
+ def to_riddle_for_delta(offset, position)
56
+ source = Riddle::Configuration::SQLSource.new(
57
+ "#{index.delta_name}_#{position}", adapter.sphinx_identifier
58
+ )
59
+ source.parent = "#{index.core_name}_#{position}"
60
+
61
+ set_source_database_settings source
62
+ set_source_attributes source, offset, true
63
+ set_source_settings source
64
+ set_source_sql source, offset, true
65
+
66
+ source
67
+ end
68
+
69
+ def delta?
70
+ !@index.delta_object.nil?
71
+ end
72
+
73
+ # Gets the association stack for a specific key.
74
+ #
75
+ def association(key)
76
+ @associations[key] ||= Association.children(@model, key)
77
+ end
78
+
79
+ private
80
+
81
+ def adapter
82
+ @adapter ||= @model.sphinx_database_adapter
83
+ end
84
+
85
+ def set_source_database_settings(source)
86
+ config = @database_configuration
87
+
88
+ source.sql_host = config[:host] || "localhost"
89
+ source.sql_user = config[:username] || config[:user] || 'root'
90
+ source.sql_pass = (config[:password].to_s || "").gsub('#', '\#')
91
+ source.sql_db = config[:database]
92
+ source.sql_port = config[:port]
93
+ source.sql_sock = config[:socket]
94
+ end
95
+
96
+ def set_source_attributes(source, offset, delta = false)
97
+ attributes.each do |attrib|
98
+ source.send(attrib.type_to_config) << attrib.config_value(offset, delta)
99
+ end
100
+ end
101
+
102
+ def set_source_sql(source, offset, delta = false)
103
+ source.sql_query = to_sql(:offset => offset, :delta => delta).gsub(/\n/, ' ')
104
+ source.sql_query_range = to_sql_query_range(:delta => delta)
105
+ source.sql_query_info = to_sql_query_info(offset)
106
+
107
+ source.sql_query_pre += send(!delta ? :sql_query_pre_for_core : :sql_query_pre_for_delta)
108
+
109
+ if @index.local_options[:group_concat_max_len]
110
+ source.sql_query_pre << "SET SESSION group_concat_max_len = #{@index.local_options[:group_concat_max_len]}"
111
+ end
112
+
113
+ source.sql_query_pre += [adapter.utf8_query_pre].compact if utf8?
114
+ source.sql_query_pre << adapter.utc_query_pre
115
+ end
116
+
117
+ def set_source_settings(source)
118
+ config = ThinkingSphinx::Configuration.instance
119
+ config.source_options.each do |key, value|
120
+ source.send("#{key}=".to_sym, value)
121
+ end
122
+
123
+ source_options = ThinkingSphinx::Configuration::SourceOptions
124
+ @options.each do |key, value|
125
+ if source_options.include?(key.to_s) && !value.nil?
126
+ source.send("#{key}=".to_sym, value)
127
+ end
128
+ end
129
+ end
130
+
131
+ # Returns all associations used amongst all the fields and attributes.
132
+ # This includes all associations between the model and what the actual
133
+ # columns are from.
134
+ #
135
+ def all_associations
136
+ @all_associations ||= (
137
+ # field associations
138
+ @fields.collect { |field|
139
+ field.associations.values
140
+ }.flatten +
141
+ # attribute associations
142
+ @attributes.collect { |attrib|
143
+ attrib.associations.values if attrib.include_as_association?
144
+ }.compact.flatten +
145
+ # explicit joins
146
+ @joins.collect { |join|
147
+ join.associations
148
+ }.flatten
149
+ ).uniq.collect { |assoc|
150
+ # get ancestors as well as column-level associations
151
+ assoc.ancestors
152
+ }.flatten.uniq
153
+ end
154
+
155
+ def utf8?
156
+ @index.options[:charset_type] =~ /utf-8|zh_cn.utf-8/
157
+ end
158
+ end
159
+ end