Use a weighted search

src/Query.php

@@ -33,6 +33,8 @@
 namespace Opus\Search;
 
 use InvalidArgumentException;
+use Opus\Common\Config;
+use Opus\Search\Config as SearchConfig;
 use Opus\Search\Facet\Set;
 use Opus\Search\Filter\AbstractFilterBase;
 use RuntimeException;
@@ -42,6 +44,7 @@
 use function array_merge;
 use function array_shift;
 use function array_unique;
+use function boolval;
 use function count;
 use function ctype_digit;
 use function intval;
@@ -74,7 +77,7 @@
  * @method int getRows( int $default = null )
  * @method string[] getFields( array $default = null )
  * @method array getSort( array $default = null )
- * @method bool getUnion( bool $default = null )
+ * @method bool getUnion( bool $default = false )
  * @method AbstractFilterBase getFilter(AbstractFilterBase $default = null ) retrieves condition to be met by resulting documents
  * @method Set getFacet( Set $default = null )
  * @method $this setStart( int $offset )
@@ -86,6 +89,8 @@
  * @method $this setFacet( Set $facet )
  * @method $this addFields( string $fields )
  * @method $this addSort( $sorting )
+ * @method $this setWeightedSearch( bool $isWeightedSearch )
+ * @method $this setWeightedFields( int[] $weightedFields ) assigns boost factors to fields (e.g. [ 'title' => 10, 'abstract' => 0.5 ])
  */
 class Query
 {
@@ -95,14 +100,16 @@ class Query
     public function reset()
     {
         $this->data = [
-            'start'      => null,
-            'rows'       => null,
-            'fields'     => null,
-            'sort'       => null,
-            'union'      => null,
-            'filter'     => null,
-            'facet'      => null,
-            'subfilters' => null,
+            'start'          => null,
+            'rows'           => null,
+            'fields'         => null,
+            'sort'           => null,
+            'union'          => false,
+            'filter'         => null,
+            'facet'          => null,
+            'subfilters'     => null,
+            'weightedsearch' => null, // first getWeightedSearch() call will set this to true or false
+            'weightedfields' => null,
         ];
     }
 
@@ -184,6 +191,46 @@ protected function normalizeDirection($ascending)
         return $ascending;
     }
 
+    /**
+     * Returns true if a weighted search shall be used, otherwise returns false.
+     *
+     * @return bool
+     */
+    public function getWeightedSearch()
+    {
+        if ($this->data['weightedsearch'] === null) {
+            $config = Config::get();
+
+            if (isset($config->search->weightedSearch)) {
+                $this->data['weightedsearch'] = boolval($config->search->weightedSearch);
+            } else {
+                $this->data['weightedsearch'] = false;
+            }
+        }
+
+        return $this->data['weightedsearch'];
+    }
+
+    /**
+     * Returns boost factors keyed by field (e.g. [ 'title' => 10, 'abstract' => 0.5 ]).
+     *
+     * @return int[]
+     */
+    public function getWeightedFields()
+    {
+        if ($this->data['weightedfields'] === null) {
+            $config = Config::get();
+
+            if (isset($config->search->simple)) {
+                $this->data['weightedfields'] = $config->search->simple->toArray();
+            } else {
+                $this->data['weightedfields'] = [];
+            }
+        }
+
+        return $this->data['weightedfields'];
+    }
+
     /**
      * Retrieves value of selected query parameter.
      *
@@ -267,6 +314,7 @@ public function set($name, $value, $adding = false)
                 break;
 
             case 'union':
+            case 'weightedsearch':
                 if ($adding) {
                     throw new InvalidArgumentException('invalid parameter access on ' . $name);
                 }
@@ -300,6 +348,18 @@ public function set($name, $value, $adding = false)
 
             case 'subfilters':
                 throw new RuntimeException('invalid access on sub filters');
+
+            case 'weightedfields':
+                if ($adding) {
+                    throw new InvalidArgumentException('invalid parameter access on ' . $name);
+                }
+
+                if (! is_array($value)) {
+                    throw new InvalidArgumentException('invalid query fields option');
+                }
+
+                $this->data[$name] = $value;
+                break;
         }
 
         return $this;
@@ -469,7 +529,7 @@ public function getSubFilters()
      */
     public static function getParameterDefault($name, $fallbackIfMissing, $oldName = null)
     {
-        $config   = Config::getDomainConfiguration();
+        $config   = SearchConfig::getDomainConfiguration();
         $defaults = $config->parameterDefaults;
 
         if ($defaults instanceof Zend_Config) {

src/Solr/Solarium/Adapter.php

@@ -77,6 +77,7 @@
 use function file_exists;
 use function filesize;
 use function filter_var;
+use function implode;
 use function in_array;
 use function intval;
 use function is_array;
@@ -615,6 +616,19 @@ protected function applyParametersOnQuery(
                 $query->setSorts($sortings);
             }
 
+            $isWeightedSearch = $parameters->getWeightedSearch();
+            if ($isWeightedSearch === true) {
+                // get the edismax component
+                $edismax = $query->getEDisMax();
+
+                // NOTE: query is now an edismax query
+                $weightedFields = $parameters->getWeightedFields();
+                if (! empty($weightedFields)) {
+                    $queryFields = $this->getQueryFieldsString($weightedFields);
+                    $edismax->setQueryFields($queryFields);
+                }
+            }
+
             $facet = $parameters->getFacet();
             if ($facet !== null) {
                 $facetSet = $query->getFacetSet();
@@ -880,4 +894,21 @@ public function setTimeout($timeout)
             $this->client->setOptions($options, true);
         }
     }
+
+    /**
+     * Converts an array containing boost factors keyed by field into a query fields string that can be used
+     * as input for the Solr `qf` request parameter.
+     *
+     * @param int[] $weightedFields assigns boost factors to fields, e.g.: [ 'title' => 10, 'abstract' => 0.5 ]
+     * @return string query fields string, e.g.: "title^10 abstract^0.5"
+     */
+    protected function getQueryFieldsString($weightedFields)
+    {
+        $queryFields = [];
+        foreach ($weightedFields as $field => $boostFactor) {
+            $queryFields[] = "$field^$boostFactor";
+        }
+
+        return implode(' ', $queryFields);
+    }
 }

test/QueryTest.php

@@ -49,7 +49,7 @@ public function testInitiallyEmpty()
         $this->assertFalse(isset($query->rows));
         $this->assertFalse(isset($query->fields));
         $this->assertFalse(isset($query->sort));
-        $this->assertFalse(isset($query->union));
+        $this->assertFalse($query->union);
     }
 
     public function testSupportingExplicitGetter()
@@ -60,7 +60,7 @@ public function testSupportingExplicitGetter()
         $this->assertNull($query->get('rows'));
         $this->assertNull($query->get('fields'));
         $this->assertNull($query->get('sort'));
-        $this->assertNull($query->get('union'));
+        $this->assertFalse($query->get('union'));
     }
 
     public function testSupportingImplicitGetter()
@@ -71,7 +71,7 @@ public function testSupportingImplicitGetter()
         $this->assertNull($query->rows);
         $this->assertNull($query->fields);
         $this->assertNull($query->sort);
-        $this->assertNull($query->union);
+        $this->assertFalse($query->union);
     }
 
     public function testSupportingGetterMethods()
@@ -82,7 +82,7 @@ public function testSupportingGetterMethods()
         $this->assertNull($query->getRows());
         $this->assertNull($query->getFields());
         $this->assertNull($query->getSort());
-        $this->assertNull($query->getUnion());
+        $this->assertFalse($query->getUnion());
     }
 
     /**

test/Solr/Solarium/AdapterSearchingTest.php

@@ -42,10 +42,35 @@
 use Opus\Search\Util\Searcher;
 use OpusTest\Search\TestAsset\DocumentBasedTestCase;
 
+use function abs;
 use function count;
 
 class AdapterSearchingTest extends DocumentBasedTestCase
 {
+    /** @var array[] */
+    protected static $additionalDocumentPropertySets = [
+        'weightedTestDocA' => [
+            'TitleMain'     => [
+                'Value'    => 'Some Document',
+                'Language' => 'eng',
+            ],
+            'TitleAbstract' => [
+                'Value'    => 'Abstract of test document A.\nSome more text.',
+                'Language' => 'eng',
+            ],
+        ],
+        'weightedTestDocB' => [
+            'TitleMain'     => [
+                'Value'    => 'Another Test Document',
+                'Language' => 'eng',
+            ],
+            'TitleAbstract' => [
+                'Value'    => 'Abstract of document B.\nSome blah blah text.',
+                'Language' => 'eng',
+            ],
+        ],
+    ];
+
     public function testService()
     {
         $search = Service::selectSearchingService(null, 'solr');
@@ -248,4 +273,92 @@ public function testMapYearFacetIndexFieldsToYearAsset()
 
         $this->assertEquals(1, $result->getAllMatchesCount());
     }
+
+    public function testWeightedSearch()
+    {
+        $docA = $this->createDocument('weightedTestDocA');
+        $docB = $this->createDocument('weightedTestDocB');
+
+        $index = Service::selectIndexingService(null, 'solr');
+        $index->addDocumentsToIndex([$docA, $docB]);
+
+        $search = Service::selectSearchingService(null, 'solr');
+
+        $query = new Query();
+        $query->addSorting('score', false);
+
+        $filter = $search->createFilter();
+        $filter->createSimpleEqualityFilter('*')->addValue('test document');
+        $query->setFilter($filter);
+
+        // 1. with different boost factors assigned to fields, expect clearly different scores & appropriate sort order
+        $this->adjustConfiguration([
+            'search' => [
+                'weightedSearch' => true, // use the Solr eDisMax query parser
+                'simple'         => [
+                    'abstract' => 0.5,
+                    'title'    => 10,
+                ],
+            ],
+        ]);
+
+        $result  = $search->customSearch($query);
+        $matches = $result->getReturnedMatches();
+
+        $this->assertEquals(2, count($matches));
+
+        $this->assertTrue(abs($matches[0]->getScore() - $matches[1]->getScore()) > 1.0);
+
+        $this->assertEquals($docB->getId(), $matches[0]->getDocument()->getId());
+
+        // 2. with swapped boost factors, expect a swapped sort order
+        $query->setWeightedFields(['abstract' => 10.0, 'title' => 0.5]);
+
+        $result  = $search->customSearch($query);
+        $matches = $result->getReturnedMatches();
+
+        $this->assertEquals(2, count($matches));
+
+        $this->assertTrue(abs($matches[0]->getScore() - $matches[1]->getScore()) > 1.0);
+
+        $this->assertEquals($docA->getId(), $matches[0]->getDocument()->getId());
+    }
+
+    public function testWeightedSearchWithEqualWeights()
+    {
+        $docA = $this->createDocument('weightedTestDocA');
+        $docB = $this->createDocument('weightedTestDocB');
+
+        $index = Service::selectIndexingService(null, 'solr');
+        $index->addDocumentsToIndex([$docA, $docB]);
+
+        $search = Service::selectSearchingService(null, 'solr');
+
+        $query = new Query();
+        $query->setWeightedSearch(true);
+
+        $filter = $search->createFilter();
+        $filter->createSimpleEqualityFilter('*')->addValue('test document');
+        $query->setFilter($filter);
+
+        // 1. without any boost factors assigned to fields, expect roughly equal scores
+        $query->setWeightedFields([]);
+
+        $result  = $search->customSearch($query);
+        $matches = $result->getReturnedMatches();
+
+        $this->assertEquals(2, count($matches));
+
+        $this->assertTrue(abs($matches[0]->getScore() - $matches[1]->getScore()) < 1.0);
+
+        // 2. with equal boost factors, expect roughly equal scores
+        $query->setWeightedFields(['abstract' => 1.0, 'title' => 1.0]);
+
+        $result  = $search->customSearch($query);
+        $matches = $result->getReturnedMatches();
+
+        $this->assertEquals(2, count($matches));
+
+        $this->assertTrue(abs($matches[0]->getScore() - $matches[1]->getScore()) < 1.0);
+    }
 }