You are here

Home » API reference » Apache Solr Search 5 » Service.php

class Apache_Solr_Service in Apache Solr Search 5

Starting point for the Solr API. Represents a Solr server resource and has methods for pinging, adding, deleting, committing, optimizing and searching.

Example Usage: <code> ... $solr = new Apache_Solr_Service(); //or explicitly new Apache_Solr_Service('localhost', 8180, '/solr')

if ($solr->ping()) { $solr->deleteByQuery('*:*'); //deletes ALL documents - be careful :)

$document = new Apache_Solr_Document(); $document->id = uniqid(); //or something else suitably unique

$document->title = 'Some Title'; $document->content = 'Some content for this wonderful document. Blah blah blah.';

$solr->addDocument($document); //if you're going to be adding documents in bulk using addDocuments //with an array of documents is faster

$solr->commit(); //commit to see the deletes and the document $solr->optimize(); //merges multiple segments into one

//and the one we all care about, search! //any other common or custom parameters to the request handler can go in the //optional 4th array argument. $solr->search('content:blah', 0, 10, array('sort' => 'timestamp desc')); } ... </code>

@todo Investigate using other HTTP clients other than file_get_contents built-in handler. Could provide performance improvements when dealing with multiple requests by using HTTP's keep alive functionality

Hierarchy

Expanded class hierarchy of Apache_Solr_Service

File

SolrPhpClient/Apache/Solr/Service.php, line 62

View source 
class Apache_Solr_Service {

  /**
   * Response version we support
   */
  const SOLR_VERSION = '1.2';

  /**
   * Response writer we support
   *
   * @todo Solr 1.3 release may change this to SerializedPHP or PHP implementation
   */
  const SOLR_WRITER = 'json';

  /**
   * NamedList Treatment constants
   */
  const NAMED_LIST_FLAT = 'flat';
  const NAMED_LIST_MAP = 'map';

  /**
   * Servlet mappings
   */
  const PING_SERVLET = 'admin/ping';
  const UPDATE_SERVLET = 'update';
  const SEARCH_SERVLET = 'select';
  const THREADS_SERVLET = 'admin/threads';

  /**
   * Server identification strings
   *
   * @var string
   */
  protected $_host, $_port, $_path;

  /**
   * Whether {@link Apache_Solr_Response} objects should create {@link Apache_Solr_Document}s in
   * the returned parsed data
   *
   * @var boolean
   */
  protected $_createDocuments = true;

  /**
   * Whether {@link Apache_Solr_Response} objects should have multivalue fields with only a single value
   * collapsed to appear as a single value would.
   *
   * @var boolean
   */
  protected $_collapseSingleValueArrays = true;

  /**
   * How NamedLists should be formatted in the output.  This specifically effects facet counts. Valid values
   * are {@link Apache_Solr_Service::NAMED_LIST_MAP} (default) or {@link Apache_Solr_Service::NAMED_LIST_FLAT}.
   *
   * @var string
   */
  protected $_namedListTreatment = self::NAMED_LIST_MAP;

  /**
   * Query delimiters. Someone might want to be able to change
   * these (to use &amp; instead of & for example), so I've provided them.
   *
   * @var string
   */
  protected $_queryDelimiter = '?', $_queryStringDelimiter = '&';

  /**
   * Constructed servlet full path URLs
   *
   * @var string
   */
  protected $_updateUrl, $_searchUrl, $_threadsUrl;

  /**
   * Keep track of whether our URLs have been constructed
   *
   * @var boolean
   */
  protected $_urlsInited = false;

  /**
   * Stream context for posting
   *
   * @var resource
   */
  protected $_postContext;

  /**
   * Escape a value for special query characters such as ':', '(', ')', '*', '?', etc.
   *
   * NOTE: inside a phrase fewer characters need escaped, use {@link Apache_Solr_Service::escapePhrase()} instead
   *
   * @param string $value
   * @return string
   */
  public static function escape($value) {

    //list taken from http://lucene.apache.org/java/docs/queryparsersyntax.html#Escaping%20Special%20Characters
    $pattern = '/(\\+|-|&&|\\|\\||!|\\(|\\)|\\{|}|\\[|]|\\^|"|~|\\*|\\?|:|\\\\)/';
    $replace = '\\\\$1';
    return preg_replace($pattern, $replace, $value);
  }

  /**
   * Escape a value meant to be contained in a phrase for special query characters
   *
   * @param string $value
   * @return string
   */
  public static function escapePhrase($value) {
    $pattern = '/("|\\\\)/';
    $replace = '\\\\$1';
    return preg_replace($pattern, $replace, $value);
  }

  /**
   * Convenience function for creating phrase syntax from a value
   *
   * @param string $value
   * @return string
   */
  public static function phrase($value) {
    return '"' . self::escapePhrase($value) . '"';
  }

  /**
   * Constructor. All parameters are optional and will take on default values
   * if not specified.
   *
   * @param string $host
   * @param string $port
   * @param string $path
   */
  public function __construct($host = 'localhost', $port = 8180, $path = '/solr/') {
    $this
      ->setHost($host);
    $this
      ->setPort($port);
    $this
      ->setPath($path);
    $this
      ->_initUrls();

    //set up the stream context for posting with file_get_contents
    $contextOpts = array(
      'http' => array(
        'method' => 'POST',
        'header' => "Content-Type: text/xml; charset=UTF-8\r\n",
      ),
    );
    $this->_postContext = stream_context_create($contextOpts);
  }

  /**
   * Return a valid http URL given this server's host, port and path and a provided servlet name
   *
   * @param string $servlet
   * @return string
   */
  protected function _constructUrl($servlet, $params = array()) {
    if (count($params)) {

      //escape all parameters appropriately for inclusion in the query string
      $escapedParams = array();
      foreach ($params as $key => $value) {
        $escapedParams[] = urlencode($key) . '=' . urlencode($value);
      }
      $queryString = $this->_queryDelimiter . implode($this->_queryStringDelimiter, $escapedParams);
    }
    else {
      $queryString = '';
    }
    return 'http://' . $this->_host . ':' . $this->_port . $this->_path . $servlet . $queryString;
  }

  /**
   * Construct the Full URLs for the three servlets we reference
   */
  protected function _initUrls() {

    //Initialize our full servlet URLs now that we have server information
    $this->_updateUrl = $this
      ->_constructUrl(self::UPDATE_SERVLET, array(
      'wt' => self::SOLR_WRITER,
    ));
    $this->_searchUrl = $this
      ->_constructUrl(self::SEARCH_SERVLET);
    $this->_threadsUrl = $this
      ->_constructUrl(self::THREADS_SERVLET, array(
      'wt' => self::SOLR_WRITER,
    ));
    $this->_urlsInited = true;
  }

  /**
   * Central method for making a get operation against this Solr Server
   *
   * @param string $url
   * @param float $timeout Read timeout in seconds
   * @return Apache_Solr_Response
   *
   * @todo implement timeout ability
   * @throws Exception If a non 200 response status is returned
   */
  protected function _sendRawGet($url, $timeout = FALSE) {

    //$http_response_header is set by file_get_contents
    $http_response_header = NULL;
    $response = new Apache_Solr_Response(@file_get_contents($url), $http_response_header, $this->_createDocuments, $this->_collapseSingleValueArrays);
    if ($response
      ->getHttpStatus() != 200) {
      throw new Exception('"' . $response
        ->getHttpStatus() . '" Status: ' . $response
        ->getHttpStatusMessage(), $response
        ->getHttpStatus());
    }
    return $response;
  }

  /**
   * Central method for making a post operation against this Solr Server
   *
   * @param string $url
   * @param string $rawPost
   * @param float $timeout Read timeout in seconds
   * @param string $contentType
   * @return Apache_Solr_Response
   *
   * @throws Exception If a non 200 response status is returned
   */
  protected function _sendRawPost($url, $rawPost, $timeout = FALSE, $contentType = 'text/xml; charset=UTF-8') {

    //ensure content type is correct
    stream_context_set_option($this->_postContext, 'http', 'header', 'Content-Type: ' . $contentType);

    //set the read timeout if specified
    if ($timeout !== FALSE) {
      stream_context_set_option($this->_postContext, 'http', 'timeout', $timeout);
    }

    //set the content
    stream_context_set_option($this->_postContext, 'http', 'content', $rawPost);

    //$http_response_header is set by file_get_contents
    $response = new Apache_Solr_Response(@file_get_contents($url, false, $this->_postContext), $http_response_header, $this->_createDocuments, $this->_collapseSingleValueArrays);
    if ($response
      ->getHttpStatus() != 200) {
      throw new Exception('"' . $response
        ->getHttpStatus() . '" Status: ' . $response
        ->getHttpStatusMessage(), $response
        ->getHttpStatus());
    }
    return $response;
  }

  /**
   * Returns the set host
   *
   * @return string
   */
  public function getHost() {
    return $this->_host;
  }

  /**
   * Set the host used. If empty will fallback to constants
   *
   * @param string $host
   */
  public function setHost($host) {

    //Use the provided host or use the default
    if (empty($host)) {
      throw new Exception('Host parameter is empty');
    }
    else {
      $this->_host = $host;
    }
    if ($this->_urlsInited) {
      $this
        ->_initUrls();
    }
  }

  /**
   * Get the set port
   *
   * @return integer
   */
  public function getPort() {
    return $this->_port;
  }

  /**
   * Set the port used. If empty will fallback to constants
   *
   * @param integer $port
   */
  public function setPort($port) {

    //Use the provided port or use the default
    $port = (int) $port;
    if ($port <= 0) {
      throw new Exception('Port is not a valid port number');
    }
    else {
      $this->_port = $port;
    }
    if ($this->_urlsInited) {
      $this
        ->_initUrls();
    }
  }

  /**
   * Get the set path.
   *
   * @return string
   */
  public function getPath() {
    return $this->_path;
  }

  /**
   * Set the path used. If empty will fallback to constants
   *
   * @param string $path
   */
  public function setPath($path) {
    $path = trim($path, '/');
    $this->_path = '/' . $path . '/';
    if ($this->_urlsInited) {
      $this
        ->_initUrls();
    }
  }

  /**
   * Set the create documents flag. This determines whether {@link Apache_Solr_Response} objects will
   * parse the response and create {@link Apache_Solr_Document} instances in place.
   *
   * @param unknown_type $createDocuments
   */
  public function setCreateDocuments($createDocuments) {
    $this->_createDocuments = (bool) $createDocuments;
  }

  /**
   * Get the current state of teh create documents flag.
   *
   * @return boolean
   */
  public function getCreateDocuments() {
    return $this->_createDocuments;
  }

  /**
   * Set the collapse single value arrays flag.
   *
   * @param boolean $collapseSingleValueArrays
   */
  public function setCollapseSingleValueArrays($collapseSingleValueArrays) {
    $this->_collapseSingleValueArrays = (bool) $collapseSingleValueArrays;
  }

  /**
   * Get the current state of the collapse single value arrays flag.
   *
   * @return boolean
   */
  public function getCollapseSingleValueArrays() {
    return $this->_collapseSingleValueArrays;
  }

  /**
   * Set how NamedLists should be formatted in the response data. This mainly effects
   * the facet counts format.
   *
   * @param string $namedListTreatment
   * @throws Exception If invalid option is set
   */
  public function setNamedListTreatmet($namedListTreatment) {
    switch ((string) $namedListTreatment) {
      case Apache_Solr_Service::NAMED_LIST_FLAT:
        $this->_namedListTreatment = Apache_Solr_Service::NAMED_LIST_FLAT;
        break;
      case Apache_Solr_Service::NAMED_LIST_MAP:
        $this->_namedListTreatment = Apache_Solr_Service::NAMED_LIST_MAP;
        break;
      default:
        throw new Exception('Not a valid named list treatement option');
    }
  }

  /**
   * Get the current setting for named list treatment.
   *
   * @return string
   */
  public function getNamedListTreatment() {
    return $this->_namedListTreatment;
  }

  /**
   * Set the string used to separate the path form the query string.
   * Defaulted to '?'
   *
   * @param string $queryDelimiter
   */
  public function setQueryDelimiter($queryDelimiter) {
    $this->_queryDelimiter = $queryDelimiter;
  }

  /**
   * Set the string used to separate the parameters in thequery string
   * Defaulted to '&'
   *
   * @param string $queryStringDelimiter
   */
  public function setQueryStringDelimiter($queryStringDelimiter) {
    $this->_queryStringDelimiter = $queryStringDelimiter;
  }

  /**
   * Call the /admin/ping servlet, can be used to quickly tell if a connection to the
   * server is able to be made.
   *
   * @param float $timeout maximum time to wait for ping in seconds, -1 for unlimited (default is 2)
   * @return float Actual time taken to ping the server, FALSE if timeout occurs
   */
  public function ping($timeout = 2) {
    $timeout = (double) $timeout;
    if ($timeout <= 0) {
      $timeout = -1;
    }
    $start = microtime(true);

    //to prevent strict errors
    $errno = 0;
    $errstr = '';

    //try to connect to the host with timeout
    $fp = fsockopen($this->_host, $this->_port, $errno, $errstr, $timeout);
    if ($fp) {

      //If we have a timeout set, then determine the amount of time we have left

      //in the request and set the stream timeout for the write operation
      if ($timeout > 0) {

        //do the calculation
        $writeTimeout = $timeout - (microtime(true) - $start);

        //check if we're out of time
        if ($writeTimeout <= 0) {
          fclose($fp);
          return false;
        }

        //convert to microseconds and set the stream timeout
        $writeTimeoutInMicroseconds = (int) $writeTimeout * 1000000;
        stream_set_timeout($fp, 0, $writeTimeoutInMicroseconds);
      }
      $request = 'HEAD ' . $this->_path . self::PING_SERVLET . ' HTTP/1.1' . "\r\n" . 'host: ' . $this->_host . "\r\n" . 'Connection: close' . "\r\n" . "\r\n";
      fwrite($fp, $request);

      //check the stream meta data to see if we timed out during the operation
      $metaData = stream_get_meta_data($fp);
      if (isset($metaData['timeout']) && $metaData['timeout']) {
        fclose($fp);
        return false;
      }

      //if we have a timeout set and have made it this far, determine the amount of time

      //still remaining and set the timeout appropriately before the read operation
      if ($timeout > 0) {

        //do the calculation
        $readTimeout = $timeout - (microtime(true) - $start);

        //check if we've run out of time
        if ($readTimeout <= 0) {
          fclose($fp);
          return false;
        }

        //convert to microseconds and set the stream timeout
        $readTimeoutInMicroseconds = $readTimeout * 1000000;
        stream_set_timeout($fp, 0, $readTimeoutInMicroseconds);
      }

      //at the very least we should get a response header line of

      //HTTP/1.1 200 OK
      $response = fread($fp, 15);

      //check the stream meta data to see if we timed out during the operation
      $metaData = stream_get_meta_data($fp);
      fclose($fp);

      //we're done with the connection - ignore the rest
      if (isset($metaData['timeout']) && $metaData['timeout']) {
        return false;
      }

      //finally, check the response header line
      if ($response != 'HTTP/1.1 200 OK') {
        return false;
      }

      //we made it, return the approximate ping time
      return microtime(true) - $start;
    }

    //we weren't able to make a connection
    return false;
  }

  /**
   * Call the /admin/threads servlet and retrieve information about all threads in the
   * Solr servlet's thread group. Useful for diagnostics.
   *
   * @return Apache_Solr_Response
   *
   * @throws Exception If an error occurs during the service call
   */
  public function threads() {
    return $this
      ->_sendRawGet($this->_threadsUrl);
  }

  /**
   * Raw Add Method. Takes a raw post body and sends it to the update service.  Post body
   * should be a complete and well formed "add" xml document.
   *
   * @param string $rawPost
   * @return Apache_Solr_Response
   *
   * @throws Exception If an error occurs during the service call
   */
  public function add($rawPost) {
    return $this
      ->_sendRawPost($this->_updateUrl, $rawPost);
  }

  /**
   * Add a Solr Document to the index
   *
   * @param Apache_Solr_Document $document
   * @param boolean $allowDups
   * @param boolean $overwritePending
   * @param boolean $overwriteCommitted
   * @return Apache_Solr_Response
   *
   * @throws Exception If an error occurs during the service call
   */
  public function addDocument(Apache_Solr_Document $document, $allowDups = false, $overwritePending = true, $overwriteCommitted = true) {
    $dupValue = $allowDups ? 'true' : 'false';
    $pendingValue = $overwritePending ? 'true' : 'false';
    $committedValue = $overwriteCommitted ? 'true' : 'false';
    $rawPost = '<add allowDups="' . $dupValue . '" overwritePending="' . $pendingValue . '" overwriteCommitted="' . $committedValue . '">';
    $rawPost .= $this
      ->_documentToXmlFragment($document);
    $rawPost .= '</add>';
    return $this
      ->add($rawPost);
  }

  /**
   * Add an array of Solr Documents to the index all at once
   *
   * @param array $documents Should be an array of Apache_Solr_Document instances
   * @param boolean $allowDups
   * @param boolean $overwritePending
   * @param boolean $overwriteCommitted
   * @return Apache_Solr_Response
   *
   * @throws Exception If an error occurs during the service call
   */
  public function addDocuments($documents, $allowDups = false, $overwritePending = true, $overwriteCommitted = true) {
    $dupValue = $allowDups ? 'true' : 'false';
    $pendingValue = $overwritePending ? 'true' : 'false';
    $committedValue = $overwriteCommitted ? 'true' : 'false';
    $rawPost = '<add allowDups="' . $dupValue . '" overwritePending="' . $pendingValue . '" overwriteCommitted="' . $committedValue . '">';
    foreach ($documents as $document) {
      if ($document instanceof Apache_Solr_Document) {
        $rawPost .= $this
          ->_documentToXmlFragment($document);
      }
    }
    $rawPost .= '</add>';
    return $this
      ->add($rawPost);
  }

  /**
   * Create an XML fragment from a {@link Apache_Solr_Document} instance appropriate for use inside a Solr add call
   *
   * @return string
   */
  protected function _documentToXmlFragment(Apache_Solr_Document $document) {
    $xml = '<doc>';
    foreach ($document as $key => $value) {
      $key = htmlspecialchars($key, ENT_QUOTES, 'UTF-8');
      if (is_array($value)) {
        foreach ($value as $multivalue) {
          $multivalue = htmlspecialchars($multivalue, ENT_NOQUOTES, 'UTF-8');
          $xml .= '<field name="' . $key . '">' . $multivalue . '</field>';
        }
      }
      else {
        $value = htmlspecialchars($value, ENT_NOQUOTES, 'UTF-8');
        $xml .= '<field name="' . $key . '">' . $value . '</field>';
      }
    }
    $xml .= '</doc>';
    return $xml;
  }

  /**
   * Send a commit command.  Will be synchronous unless both wait parameters are set to false.
   *
   * @param boolean $optimize Defaults to true
   * @param boolean $waitFlush Defaults to true
   * @param boolean $waitSearcher Defaults to true
   * @param float $timeout Maximum expected duration (in seconds) of the commit operation on the server (otherwise, will throw a communication exception). Defaults to 1 hour
   * @return Apache_Solr_Response
   *
   * @throws Exception If an error occurs during the service call
   */
  public function commit($optimize = true, $waitFlush = true, $waitSearcher = true, $timeout = 3600) {
    $optimizeValue = $optimize ? 'true' : 'false';
    $flushValue = $waitFlush ? 'true' : 'false';
    $searcherValue = $waitSearcher ? 'true' : 'false';
    $rawPost = '<commit optimize="' . $optimizeValue . '" waitFlush="' . $flushValue . '" waitSearcher="' . $searcherValue . '" />';
    return $this
      ->_sendRawPost($this->_updateUrl, $rawPost, $timeout);
  }

  /**
   * Raw Delete Method. Takes a raw post body and sends it to the update service. Body should be
   * a complete and well formed "delete" xml document
   *
   * @param string $rawPost Expected to be utf-8 encoded xml document
   * @return Apache_Solr_Response
   *
   * @throws Exception If an error occurs during the service call
   */
  public function delete($rawPost) {
    return $this
      ->_sendRawPost($this->_updateUrl, $rawPost);
  }

  /**
   * Create a delete document based on document ID
   *
   * @param string $id Expected to be utf-8 encoded
   * @param boolean $fromPending
   * @param boolean $fromCommitted
   * @return Apache_Solr_Response
   *
   * @throws Exception If an error occurs during the service call
   */
  public function deleteById($id, $fromPending = true, $fromCommitted = true) {
    $pendingValue = $fromPending ? 'true' : 'false';
    $committedValue = $fromCommitted ? 'true' : 'false';

    //escape special xml characters
    $id = htmlspecialchars($id, ENT_NOQUOTES, 'UTF-8');
    $rawPost = '<delete fromPending="' . $pendingValue . '" fromCommitted="' . $committedValue . '"><id>' . $id . '</id></delete>';
    return $this
      ->delete($rawPost);
  }

  /**
   * Create a delete document based on a query and submit it
   *
   * @param string $rawQuery Expected to be utf-8 encoded
   * @param boolean $fromPending
   * @param boolean $fromCommitted
   * @return Apache_Solr_Response
   *
   * @throws Exception If an error occurs during the service call
   */
  public function deleteByQuery($rawQuery, $fromPending = true, $fromCommitted = true) {
    $pendingValue = $fromPending ? 'true' : 'false';
    $committedValue = $fromCommitted ? 'true' : 'false';

    // escape special xml characters
    $rawQuery = htmlspecialchars($rawQuery, ENT_NOQUOTES, 'UTF-8');
    $rawPost = '<delete fromPending="' . $pendingValue . '" fromCommitted="' . $committedValue . '"><query>' . $rawQuery . '</query></delete>';
    return $this
      ->delete($rawPost);
  }

  /**
   * Send an optimize command.  Will be synchronous unless both wait parameters are set
   * to false.
   *
   * @param boolean $waitFlush
   * @param boolean $waitSearcher
   * @param float $timeout Maximum expected duration of the commit operation on the server (otherwise, will throw a communication exception)
   * @return Apache_Solr_Response
   *
   * @throws Exception If an error occurs during the service call
   */
  public function optimize($waitFlush = true, $waitSearcher = true, $timeout = 3600) {
    $flushValue = $waitFlush ? 'true' : 'false';
    $searcherValue = $waitSearcher ? 'true' : 'false';
    $rawPost = '<optimize waitFlush="' . $flushValue . '" waitSearcher="' . $searcherValue . '" />';
    return $this
      ->_sendRawPost($this->_updateUrl, $rawPost, $timeout);
  }

  /**
   * Simple Search interface
   *
   * @param string $query The raw query string
   * @param int $offset The starting offset for result documents
   * @param int $limit The maximum number of result documents to return
   * @param array $params key / value pairs for other query parameters (see Solr documentation), use arrays for parameter keys used more than once (e.g. facet.field)
   * @return Apache_Solr_Response
   *
   * @throws Exception If an error occurs during the service call
   */
  public function search($query, $offset = 0, $limit = 10, $params = array()) {
    if (!is_array($params)) {
      $params = array();
    }

    // construct our full parameters
    // sending the version is important in case the format changes
    $params['version'] = self::SOLR_VERSION;

    // common parameters in this interface
    $params['wt'] = self::SOLR_WRITER;
    $params['json.nl'] = $this->_namedListTreatment;
    $params['q'] = $query;
    $params['start'] = $offset;
    $params['rows'] = $limit;

    // use http_build_query to encode our arguments because its faster
    // than urlencoding all the parts ourselves in a loop
    $queryString = http_build_query($params, null, $this->_queryStringDelimiter);

    // because http_build_query treats arrays differently than we want to, correct the query
    // string by changing foo[#]=bar (# being an actual number) parameter strings to just
    // multiple foo=bar strings. This regex should always work since '=' will be urlencoded
    // anywhere else the regex isn't expecting it
    $queryString = preg_replace('/%5B(?:[0-9]|[1-9][0-9]+)%5D=/', '=', $queryString);
    return $this
      ->_sendRawGet($this->_searchUrl . $this->_queryDelimiter . $queryString);
  }

}

Members

Namesort descending Modifiers Type Description Overrides
Apache_Solr_Service::$_collapseSingleValueArrays protected property Whether {@link Apache_Solr_Response} objects should have multivalue fields with only a single value collapsed to appear as a single value would.
Apache_Solr_Service::$_createDocuments protected property Whether {@link Apache_Solr_Response} objects should create {@link Apache_Solr_Document}s in the returned parsed data
Apache_Solr_Service::$_host protected property Server identification strings
Apache_Solr_Service::$_namedListTreatment protected property How NamedLists should be formatted in the output. This specifically effects facet counts. Valid values are {@link Apache_Solr_Service::NAMED_LIST_MAP} (default) or {@link Apache_Solr_Service::NAMED_LIST_FLAT}.
Apache_Solr_Service::$_postContext protected property Stream context for posting
Apache_Solr_Service::$_queryDelimiter protected property Query delimiters. Someone might want to be able to change these (to use &amp; instead of & for example), so I've provided them.
Apache_Solr_Service::$_updateUrl protected property Constructed servlet full path URLs
Apache_Solr_Service::$_urlsInited protected property Keep track of whether our URLs have been constructed
Apache_Solr_Service::add public function Raw Add Method. Takes a raw post body and sends it to the update service. Post body should be a complete and well formed "add" xml document.
Apache_Solr_Service::addDocument public function Add a Solr Document to the index
Apache_Solr_Service::addDocuments public function Add an array of Solr Documents to the index all at once
Apache_Solr_Service::commit public function Send a commit command. Will be synchronous unless both wait parameters are set to false.
Apache_Solr_Service::delete public function Raw Delete Method. Takes a raw post body and sends it to the update service. Body should be a complete and well formed "delete" xml document
Apache_Solr_Service::deleteById public function Create a delete document based on document ID
Apache_Solr_Service::deleteByQuery public function Create a delete document based on a query and submit it
Apache_Solr_Service::escape public static function Escape a value for special query characters such as ':', '(', ')', '*', '?', etc.
Apache_Solr_Service::escapePhrase public static function Escape a value meant to be contained in a phrase for special query characters
Apache_Solr_Service::getCollapseSingleValueArrays public function Get the current state of the collapse single value arrays flag.
Apache_Solr_Service::getCreateDocuments public function Get the current state of teh create documents flag.
Apache_Solr_Service::getHost public function Returns the set host
Apache_Solr_Service::getNamedListTreatment public function Get the current setting for named list treatment.
Apache_Solr_Service::getPath public function Get the set path.
Apache_Solr_Service::getPort public function Get the set port
Apache_Solr_Service::NAMED_LIST_FLAT constant NamedList Treatment constants
Apache_Solr_Service::NAMED_LIST_MAP constant
Apache_Solr_Service::optimize public function Send an optimize command. Will be synchronous unless both wait parameters are set to false.
Apache_Solr_Service::phrase public static function Convenience function for creating phrase syntax from a value
Apache_Solr_Service::ping public function Call the /admin/ping servlet, can be used to quickly tell if a connection to the server is able to be made.
Apache_Solr_Service::PING_SERVLET constant Servlet mappings
Apache_Solr_Service::search public function Simple Search interface
Apache_Solr_Service::SEARCH_SERVLET constant
Apache_Solr_Service::setCollapseSingleValueArrays public function Set the collapse single value arrays flag.
Apache_Solr_Service::setCreateDocuments public function Set the create documents flag. This determines whether {@link Apache_Solr_Response} objects will parse the response and create {@link Apache_Solr_Document} instances in place.
Apache_Solr_Service::setHost public function Set the host used. If empty will fallback to constants
Apache_Solr_Service::setNamedListTreatmet public function Set how NamedLists should be formatted in the response data. This mainly effects the facet counts format.
Apache_Solr_Service::setPath public function Set the path used. If empty will fallback to constants
Apache_Solr_Service::setPort public function Set the port used. If empty will fallback to constants
Apache_Solr_Service::setQueryDelimiter public function Set the string used to separate the path form the query string. Defaulted to '?'
Apache_Solr_Service::setQueryStringDelimiter public function Set the string used to separate the parameters in thequery string Defaulted to '&'
Apache_Solr_Service::SOLR_VERSION constant Response version we support
Apache_Solr_Service::SOLR_WRITER constant Response writer we support
Apache_Solr_Service::threads public function Call the /admin/threads servlet and retrieve information about all threads in the Solr servlet's thread group. Useful for diagnostics.
Apache_Solr_Service::THREADS_SERVLET constant
Apache_Solr_Service::UPDATE_SERVLET constant
Apache_Solr_Service::_constructUrl protected function Return a valid http URL given this server's host, port and path and a provided servlet name
Apache_Solr_Service::_documentToXmlFragment protected function Create an XML fragment from a {@link Apache_Solr_Document} instance appropriate for use inside a Solr add call
Apache_Solr_Service::_initUrls protected function Construct the Full URLs for the three servlets we reference
Apache_Solr_Service::_sendRawGet protected function Central method for making a get operation against this Solr Server
Apache_Solr_Service::_sendRawPost protected function Central method for making a post operation against this Solr Server
Apache_Solr_Service::__construct public function Constructor. All parameters are optional and will take on default values if not specified.