Combining Multiple Consequences

Dataset Example

Let’s say we have the following dataset. Some movies have Clint Eastwood as an actor, some as a director, and some have both.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
[
  {
    "title": "The Good, the Bad and the Ugly",
    "director": "Sergio Leone",
    "actors": ["Clint Eastwood", "Lee Van Cleef", "Elli Wallach"]
  },
  {
    "title": "Dirty Harry",
    "director": "Don Siegel",
    "actors": ["Clint Eastwood", "Andy Robinson", "Harry Guardino"]
  },
  {
    "title": "Million Dollar Baby",
    "director": "Clint Eastwood",
    "actors": ["Clint Eastwood", "Hilary Swank", "Morgan Freeman"]
  },
  {
    "title": "Invictus",
    "director": "Clint Eastwood",
    "actors": ["Morgan Freeman", "Matt Damon", "Tony Kgoroge"]
  }
]

If someone searches for “clint eastwood”, they would retrieve all movies by or with Clint Eastwood, even if they were only interested in movies with Clint Eastwood as the director. You could solve this problem with faceting, by setting director as an attribute for faceting and providing a refinement list with its own search input on your front end.

Yet, an even better way of helping your end user would be to make your search smart and look only for movies where director is equal to “Clint Eastwood” whenever they type “clint eastwood director”. To achieve this, you first need to set director in your list of attributes for faceting. Then, you can create a new rule that filters on matching attributes.

Concretely, you’ll need to create two consequences whenever a user types in “clint eastwood director”:

• filter all results with director
• remove the word “director” from the search

Using the API

First, you need to set director as attributesForFaceting. This happens at indexing time.

1
2
3
4
5
$index->setSettings([
  'attributesForFaceting' => [
    "director"
  ]
]);

1
2
3
4
5
index.set_settings({
  attributesForFaceting: [
    'director'
  ]
})

1
2
3
4
5
index.setSettings({
  attributesForFaceting: [
    'director'
  ]
});

1
2
3
4
5
index.set_settings({
    'attributesForFaceting': [
        'director'
    ]
})

1
2
3
4
5
index.setSettings([
  "attributesForFaceting": [
    "director"
  ]
])

1
2
3
4
5
6
7
final JSONObject res = index.setSettings(
  new JSONObject().put(
    "attributesForFaceting",
    new JSONArray()
      .put("director")
  )
);

1
2
3
4
5
6
7
8
9
IndexSettings settings = new IndexSettings
{
    AttributeForDistinct = "director"
};

index.SetSettings(settings);

// Asynchronous
await index.SetSettingsAsync(settings);

1
2
index.setSettings(new IndexSettings()
              .setAttributesForFaceting(Collections.singletonList("director")));

1
2
3
res, err := index.SetSettings(search.Settings{
  AttributesForFaceting: opt.AttributesForFaceting("director"),
})

1
2
3
4
5
6
7
client.execute {
  changeSettings of "myIndex" `with` IndexSettings(
    attributesForFaceting = Some(Seq(
      "director"
    ))
  )
}

1
2
3
4
5
6
7
val settings = settings {
    attributesForFaceting {
        +"director"
    }
}

index.setSettings(settings)

Then, you can set a query rule that detects the term “director” in a query whenever it comes after a term that matches the name of a director, and applies a filter on facet value director:'Clint Eastwood'. For this, you need to use the saveRule method.

However, setting the rule isn’t enough. Even when you set a rule, the engine still tries to match on the terms of the query. If a user searches for “clint eastwood director”, even if your rule applies, the engine will look for the word “director” in the records. With our dataset, this would return no results at all. This is where combining consequences comes in handy.

You can add another consequence, to remove the word “director” from the query, when this rule applies. This way, it won’t be used as a search term, only for filtering purposes.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
$rule = [
  'objectID' => 'director-rule',
  'condition' => [
    'pattern'   => '{facet:director} director',
    'anchoring' => 'contains',
  ],
  'consequence' => [
    'params' => [
      'automaticFacetFilters' => ['director'],
      'query' => [
        'edits' => [
          [
            'type' => 'remove',
            'delete' => 'director'
          ]
        ]
      ]
    ]
  ]
];

$response = $index->saveRule($rule);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
rule = {
  objectID: 'director-rule',
  condition: {
    pattern: '{facet:director} director',
    anchoring: 'contains'
  },
  consequence: {
    params: {
      automaticFacetFilters: ['director'],
      query: {
        edits: [
          {
            type: 'remove',
            delete: 'director'
          }
        ]
      }
    }
  }
}

index.save_rule(rule['objectID'], rule)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
const rule = {
  objectID: 'director-rule',
  condition: {
    pattern: '{facet:director} director',
    anchoring: 'contains'
  },
  consequence: {
    params: {
      automaticFacetFilters: 'director',
      query: {
        edits: [
          type: 'remove',
          delete: 'director'
        ]
      }
    }
  }
};

index.saveRule(rule, (err, content) => {
  if (err) throw err;
  console.log(content);
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
rule = {
    'objectID': 'director-rule',
    'condition': {
        'pattern': '{facet:director} director',
        'anchoring': 'contains'
    },
  'consequence': {
        'params': {
            'automaticFacetFilters': ['director'],
            'query': {
                'edits': [{
                    'type': 'remove',
                    'delete': 'director'
                }]
            }
        }
    }
}

response = index.save_rule(rule)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
var rule = new Rule
{
  ObjectID = "director-rule",
  Condition = new Condition { Anchoring = "contains", Pattern = "{facet:director} director" },
  Consequence = new Consequence
  {
    Params = new ConsequenceParams
    {
      AutomaticFacetFilters = new List<AutomaticFacetFilter>
      {
        new AutomaticFacetFilter { Facet = "director" }
      },
      Query = new ConsequenceQuery
      {
          Edits = new List<Edit>
          {
              new Edit { Type = EditType.Remove, Delete = "director" }
          }
      }
    }
  }
};

index.SaveRule(rule);

// Asynchronous
await index.SaveRuleAsync(rule);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Condition condition =
        new Condition().setPattern("{facet:director} director").setAnchoring("contains");

ConsequenceParams params =
        new ConsequenceParams()
                .setAutomaticFacetFilters(Collections.singletonList(new AutomaticFacetFilter("director")))
                .setConsequenceQuery(
                        new ConsequenceQuery()
                                .setEdits(Collections.singletonList(new Edit().setDelete("director"))));

Consequence consequence = new Consequence().setParams(params);

Rule rule =
        new Rule().setObjectID("director-rule").setCondition(condition).setConsequence(consequence);

index.saveRule(rule);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
rule := search.Rule{
  ObjectID:  "director-rule",
  Condition: search.RuleCondition{Anchoring: search.Contains, Pattern: "{facet:director} director"},
  Consequence: search.RuleConsequence{
    Params: &search.RuleParams{
      AutomaticFacetFilters: []search.AutomaticFacetFilter{{Facet: "director"}},
      Query: search.NewRuleQueryObject(
        search.RuleQueryObjectQuery{
          Edits: []search.QueryEdit{search.RemoveEdit("director")},
        },
      ),
    },
  },
}

res, err := index.SaveRule(rule)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
val ruleToSave = Rule(
  objectID = "director-rule",
  condition = Condition(
    pattern = "{facet:director} director",
    anchoring = "contains"
  ),
  consequence = Consequence(
    params = Seq(
      Map("automaticFacetFilters" -> Seq(
        AutomaticFacetFilters("director")
      )),
      Map(
        "query" -> Map(
          "edits" -> Seq(
            Edit("remove", "director")
          )
        )
      )
    )
  ),
)

client.execute {
  save rule ruleToSave inIndex "index_name"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
val director = Attribute("director")
val rules = rules {
    rule(
        "director_rule",
        Condition(Contains, Facet(director)),
        Consequence(
            automaticFacetFilters { +director },
            edits = edits { +"director" }
        )
    )
}

index.saveRules(rules)

Using the Dashboard

You can also add your rules in your Algolia dashboard.

1. Go to your dashboard and select your index.
2. Click the Configuration tab.
3. In the Facets subsection of Filtering and Faceting, click the “Add an attribute” button and select the director attribute from the dropdown.
4. Then, go to the Query Rules tab and click the “New Rule” button.
5. In the Condition(s) section:
   • Set the anchoring of “if the query…” to Contains.
   • Type {facet:director} director in the input field and press enter.
6. In the Consequences section:
   • Click the “Add consequence” button and select Filter Matching Attributes (or Filter/Boost Matching Attributes on Enterprise plans).
   • Type director in the Filter field and press enter.
   • Click the “Add consequence” button again and select Remove Word.
   • Type “director” in the input field and press Enter.
7. Don’t forget to save your changes!