implement optional caching of query results

Re-roll - looks anyhow like I missed the change to the mlt module. This patch uses the new cache table for the Luke cache, but does not enable any query caching by default. Per discussion with Robert, it might be useful, however, to have that facility available, especially for sites able to use a high-speed cache like memcache.

Robert - well, the main question is whether it's worth committing. The last patch will actually cause zero extra caching - existing cache_* calls will just go to a different table.

We should implement this so it only caches when block and page caching is off (e.g. for logged-in users with a node access module turned on)

probably not working yet, but starting to make progress.

maybe worth looking at

a little simpler

Damien suggests he has an alternate approach based on http headers.

here's Damien's code from: http://drupalbin.com/9269

for using Solr's if-modified-since header capability. Woudl could/should possibly combine this with a minimum cache lifetime. Again, this is mainly relevant for MLT or sother queries that might be made on every page.

Cache queries

From: Damien Tournoud <damien@tournoud.net>


---
 Drupal_Apache_Solr_Service.php |   69 ++++++++++++++++++++++++++++++++++++++--
 1 files changed, 66 insertions(+), 3 deletions(-)

diff --git Drupal_Apache_Solr_Service.php Drupal_Apache_Solr_Service.php
index 98466f0..c5f3142 100644
--- Drupal_Apache_Solr_Service.php
+++ Drupal_Apache_Solr_Service.php
@@ -203,8 +203,8 @@ class Drupal_Apache_Solr_Service extends Apache_Solr_Service {
    *
    * @see Apache_Solr_Service::_sendRawGet()
    */
-  protected function _sendRawGet($url, $timeout = FALSE) {
-    list ($data, $headers) = $this->_makeHttpRequest($url, 'GET', array(), '', $timeout);
+  protected function _sendRawGet($url, $timeout = FALSE, $cachable = FALSE) {
+    list ($data, $headers) = $this->_makeHttpRequest($url, 'GET', array(), '', $timeout, $cachable);
     $response = new Apache_Solr_Response($data, $headers, $this->_createDocuments, $this->_collapseSingleValueArrays);
     if ($response->getHttpStatus() != 200) {
       throw new Exception('"' . $response->getHttpStatus() . '" Status: ' . $response->getHttpStatusMessage());
@@ -227,17 +227,47 @@ class Drupal_Apache_Solr_Service extends Apache_Solr_Service {
     return $response;
   }
 
-  protected function _makeHttpRequest($url, $method = 'GET', $headers = array(), $content = '', $timeout = FALSE) {
+  protected function _makeHttpRequest($url, $method = 'GET', $headers = array(), $content = '', $timeout = FALSE, $cachable = FALSE) {
+    // Caching is only possible for GET requests.
+    $cachable &= $method == 'GET';
+
+    // Try to pull out a previous query from the cache.
+    if ($cachable && ($cache = cache_get('apachesolr_query:' . sha1($url)))) {
+      $cached_result = $cache->data;
+      if ($cached_result['url'] == $url) {
+        $headers['If-Modified-Since'] = $cached_result['headers']['Last-Modified'];
+        $headers['E-Tag'] = $cached_result['headers']['ETag'];
+      }
+    }
+
     // Set a response timeout
     if ($timeout) {
       $default_socket_timeout = ini_set('default_socket_timeout', $timeout);
     }
+
     $result = drupal_http_request($url, $headers, $method, $content);
+
     // Restore the response timeout
     if ($timeout) {
       ini_set('default_socket_timeout', $default_socket_timeout);
     }
 
+    // Not Modified, use the cached response.
+    if ($cachable && $result->code == 304) {
+      $result->code = 200;
+      $result->headers = $cached_result['headers'];
+      $result->data = $cached_result['data'];
+    }
+    // Store the response.
+    else if ($cachable && ($result->code == 200) && isset($result->headers['Last-Modified']) && isset($result->headers['ETag'])) {
+      $cache = array(
+        'url' => $url,
+        'headers' => $result->headers,
+        'data' => $result->data
+      );
+      cache_set('apachesolr_query:' . sha1($url), $cache);
+    }
+
     // This will no longer be needed after http://drupal.org/node/345591 is committed
     $responses = array(
       0 => 'Request failed',
@@ -273,4 +303,37 @@ class Drupal_Apache_Solr_Service extends Apache_Solr_Service {
     }
     return array($result->data, $headers);
   }
+
+  /**
+   * Perform a search query, with optional caching.
+   */
+  public function search($query, $offset = 0, $limit = 10, $params = array(), $cachable = FALSE) {
+    if (!is_array($params)) {
+      $params = array();
+    }
+
+    // Construct our full parameters.
+    $params += array(
+      // Sending the version is important in case the format changes.
+      'version' => self::SOLR_VERSION,
+      // Common parameters in this interface.
+      'wt' => self::SOLR_WRITER,
+      'json.nl' => $this->_namedListTreatment,
+      'q' => $query,
+      'start' => $offset,
+      '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, FALSE, $cachable);
+  }
 }

This is a big part of what Damien's suggested code does - though using Drupal essentially instead of a HTTP cache