Class: Solr::Connection

Inherits:
Object
  • Object
show all
Defined in:
lib/solr/connection.rb

Overview

TODO: add a convenience method to POST a Solr .xml file, like Solr’s example post.sh

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(url = "http://localhost:8983/solr", opts = {}) ⇒ Connection

create a connection to a solr instance using the url for the solr application context:

conn = Solr::Connection.new("http://example.com:8080/solr")

if you would prefer to have all adds/updates autocommitted, use :autocommit => :on

conn = Solr::Connection.new('http://example.com:8080/solr', 
  :autocommit => :on)



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/solr/connection.rb', line 29

def initialize(url="http://localhost:8983/solr", opts={})
  @url = URI.parse(url)
  unless @url.kind_of? URI::HTTP
    raise "invalid http url: #{url}"
  end

  # TODO: Autocommit seems nice at one level, but it currently is confusing because
  # only calls to Connection#add/#update/#delete, though a Connection#send(AddDocument.new(...))
  # does not autocommit.  Maybe #send should check for the request types that require a commit and
  # commit in #send instead of the individual methods?
  @autocommit = opts[:autocommit] == :on

  # Not actually opening the connection yet, just setting up the persistent connection.
  @connection = Net::HTTP.new(@url.host, @url.port)
  
  @connection.read_timeout = opts[:timeout] if opts[:timeout]
  @username = opts[:username] if opts[:username]
  @password = opts[:password] if opts[:password]
end

Instance Attribute Details

#autocommit ⇒ Object (readonly)

Returns the value of attribute autocommit.



16
17
18
 
# File 'lib/solr/connection.rb', line 16

def autocommit
  @autocommit
end

#connection ⇒ Object (readonly)

Returns the value of attribute connection.



16
17
18
 
# File 'lib/solr/connection.rb', line 16

def connection
  @connection
end

#url ⇒ Object (readonly)

Returns the value of attribute url.



16
17
18
 
# File 'lib/solr/connection.rb', line 16

def url
  @url
end

Instance Method Details

#add(doc) ⇒ Object

add a document to the index. you can pass in either a hash

conn.add(:id => 123, :title => 'Tlon, Uqbar, Orbis Tertius')

or a Solr::Document

conn.add(Solr::Document.new(:id => 123, :title = 'On Writing')

true/false will be returned to designate success/failure



59
60
61
62
63
64
 
# File 'lib/solr/connection.rb', line 59

def add(doc)
  request = Solr::Request::AddDocument.new(doc)
  response = send(request)
  commit if @autocommit
  return response.ok?
end

#commit(options = {}) ⇒ Object

sends a commit message to the server



109
110
111
112
 
# File 'lib/solr/connection.rb', line 109

def commit(options={})
  response = send(Solr::Request::Commit.new(options))
  return response.ok?
end

#delete(document_id) ⇒ Object

delete a document from the index using the document id



131
132
133
134
135
 
# File 'lib/solr/connection.rb', line 131

def delete(document_id)
  response = send(Solr::Request::Delete.new(:id => document_id))
  commit if @autocommit
  response.ok?
end

#delete_by_query(query) ⇒ Object

delete using a query



138
139
140
141
142
 
# File 'lib/solr/connection.rb', line 138

def delete_by_query(query)
  response = send(Solr::Request::Delete.new(:query => query))
  commit if @autocommit
  response.ok?
end

#info ⇒ Object 



144
145
146
 
# File 'lib/solr/connection.rb', line 144

def info
  send(Solr::Request::IndexInfo.new)
end

#optimize ⇒ Object

sends an optimize message to the server



115
116
117
118
 
# File 'lib/solr/connection.rb', line 115

def optimize
  response = send(Solr::Request::Optimize.new)
  return response.ok?
end

#ping ⇒ Object

pings the connection and returns true/false if it is alive or not



121
122
123
124
125
126
127
128
 
# File 'lib/solr/connection.rb', line 121

def ping
  begin
    response = send(Solr::Request::Ping.new)
    return response.ok?
  rescue
    return false
  end
end

#post(request) ⇒ Object

send the http post request to solr; for convenience there are shortcuts to some requests: add(), query(), commit(), delete() or send()



157
158
159
160
161
162
163
164
165
166
167
168
169
 
# File 'lib/solr/connection.rb', line 157

def post(request)
  req = Net::HTTP::Post.new(@url.path + "/" + request.handler,
    { "Content-Type" => request.content_type })
  req.basic_auth(@username, @password) if @username && @password
  response = @connection.request(req, request.to_s)

  case response
  when Net::HTTPSuccess then response.body
  else
    response.error!
  end

end

#query(query, options = {}, &action) ⇒ Object

performs a standard query and returns a Solr::Response::Standard

response = conn.query('borges')

alternative you can pass in a block and iterate over hits

conn.query('borges') do |hit|
  puts hit
end

options include:

:sort, :default_field, :rows, :filter_queries, :debug_query,
:explain_other, :facets, :highlighting, :mlt,
:operator         => :or / :and
:start            => defaults to 0
:field_list       => array, defaults to ["*", "score"]



90
91
92
93
 
# File 'lib/solr/connection.rb', line 90

def query(query, options={}, &action)
  # TODO: Shouldn't this return an exception if the Solr status is not ok?  (rather than true/false).
  create_and_send_query(Solr::Request::Standard, options.update(:query => query), &action)
end

#search(query, options = {}, &action) ⇒ Object

performs a dismax search and returns a Solr::Response::Standard

response = conn.search('borges')

options are same as query, but also include:

:tie_breaker, :query_fields, :minimum_match, :phrase_fields,
:phrase_slop, :boost_query, :boost_functions



104
105
106
 
# File 'lib/solr/connection.rb', line 104

def search(query, options={}, &action)
  create_and_send_query(Solr::Request::Dismax, options.update(:query => query), &action)
end

#send(request) ⇒ Object

send a given Solr::Request and return a RubyResponse or XmlResponse depending on the type of request



150
151
152
153
 
# File 'lib/solr/connection.rb', line 150

def send(request)
  data = post(request)
  Solr::Response::Base.make_response(request, data)
end

#update(doc) ⇒ Object

update a document in the index (really just an alias to add)



68
69
70
 
# File 'lib/solr/connection.rb', line 68

def update(doc)
  return add(doc)
end