Merchandising on empty queries

This guide shows you how to create a rule that boosts the category clearance:true, whenever there is an empty query and the context is set to landing. You can use other consequences, such as promoting or hiding items, and boosting or burying categories, with the same condition. To trigger this rule, you must send landing as a ruleContexts on the frontend.

As soon as user begins typing, the rule is turned off. If you want a rule that’s always active for a particular context regardless of the query string, create a context-only rule. For more information, see Using rules to customize search results by platform.

To boost, bury, or filter on values of a certain attribute, you must declare that attribute as an attributesForFaceting.

Rules on empty queries are useful for landing or category pages. Use either filters or context to determine which category pages should trigger these rules.

Guides Category Pages

Merchandise category pages

Using the API

To create a rule with an API client, use the saveRule method on a Rule object with an empty search as the condition.

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// turn json into an array
$rule = array(
    'objectID' => 'clearance-category-filter',
    'conditions' => array(
      array(
        'pattern' => '',
        'anchoring' => 'is'
      ),
      array(
        'context' => 'landing',
      ),
    ),
    'consequence' => array(
        'params' => array(
            'optionalFilters' => 'clearance:true'
        )
    )
);
// push Rule to index
$index->saveRule($rule);

1
2
3
4
5
6
7
8
9
10
11
12
13
index.save_rule('clearance-category-filter', {
      objectID: 'clearance-category-filter',
      conditions: [{
          pattern: '',
          anchoring: 'is',
          context: 'landing'
      }],
      consequence: {
          params: {
              optionalFilters: 'clearance:true'
          }
      }
  })

1
2
3
4
5
6
7
8
9
10
11
index.saveRule({
  objectID: 'clearance-category-filter',
  conditions: [{
    pattern: '',
    anchoring: 'is',
    context: "landing"
  }],
  consequence: {
    optionalFilters: 'clearance:true',
  },
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
rule = {
    "objectID": "clearance-category-filter",
    "conditions": [{
        "anchoring": "is",
        "pattern": "",
        "context": "landing"
    }],
    "consequence": {
        "params": {
            "optionalFilters": "clearance:true",
        },
    },
}
response = index.save_rule(rule)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
let rule = Rule(objectID: "clearance-category-filter")
  .set(\.conditions, to: [
    Rule.Condition()
      .set(\.anchoring, to: .is)
      .set(\.pattern, to: .literal(""))
      .set(\.context, to: .literal("landing"))
  ])
  .set(\.consequence, to: Rule.Consequence().set(\.query, to: Query().set(\.optionalFilters, to: "clearance:true"))
)
index.saveRule(rule) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
val rules = rules {
    rule(
        objectID = "clearance-category-filter",
        conditions = conditions {
          condition(anchoring = Anchoring.Is, pattern = Pattern.Literal(""), context= Context.Literal("landing"))
        },
        consequence = consequence(
            query = query {
                optionalFilters = "clearance:true"
            }
        )
    )
}
index.saveRules(rules)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
Rule ruleToSave = new Rule
{
    ObjectID = "clearance-category-filter",
    Conditions = new List<Condition>
    {
      new Condition { Anchoring = "is", Pattern = "", Context = "landing"  },
    },
    Consequence = new Consequence
    {
        Params = new ConsequenceParams
        {
            AutomaticFacetFilters = new List<AutomaticFacetFilter>
            {
                new AutomaticFacetFilter { Facet = "clearance = true" }
            }
        }
    }
};
index.SaveRule(rule, forwardToReplicas: false);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Condition condition = new Condition()
    .setAnchoring("is")
    .setPattern("")
    .setContext("landing");
ConsequenceParams params =
    new ConsequenceParams()
        .setFilters("clearance:true");
Consequence consequence = new Consequence()
    .setParams(params);
Rule rule = new Rule()
        .setObjectID("clearance-category-filter")
        .setConditions(Collections.singletonList(condition))
        .setConsequence(consequence);
index.saveRule(rule);
// Asynchronous
index.saveRuleAsync(rule);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
rule := search.Rule{
  ObjectID:  "clearance-category-filter",
  Conditions: []search.RuleCondition{
    {
      Anchoring: search.Is, Pattern: "", Context: "landing",
    },
  },
  Consequence: search.RuleConsequence{
    Params: &search.RuleParams{
      QueryParams: search.QueryParams{
        OptionalFilters: opt.OptionalFilters("clearance:true"),
      },
    },
  },
}
res, err := index.SaveRule(rule)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
val rule = Rule(
  objectID = "clearance-category-filter",
  conditions = Some(Seq(
    Condition(
      pattern = "",
      anchoring = "is",
      context = "landing"
    ))),
  consequence = Consequence(
    params = Some(
      Map(
        "optionalFilters" -> "clearance:true"
      )
    )
  )
)
client.execute {
  save rule rule inIndex "indexName"
}

Using the Visual Editor

Select the Rules section from the left sidebar menu in the Algolia dashboard.
Under the heading Rules, select the index you are adding a rule to.
Select Create your first rule or New rule. In the drop-down menu, click Visual Editor.
Select Set the search query.
In the Your search section, right below the Define the query that triggers the rule header, select is and leave the next input box empty.
In Add a context (optional), add the context “landing”. If you want to trigger this rule whenever there is an empty query, regardless of context, leave this input box empty. Select Apply.
Below What do you want to do? Select Boost categories.
Fill in the Category section to be “clearance” is “true”.
Select Apply. This will provide you a preview of the results.
Save as Draft or Review and Publish.

Using the Manual Editor

Select the Rules section from the left sidebar menu in the Algolia dashboard.
Under the heading Rules, select the index you are adding a rule to.
Select Create your first rule or New rule. In the drop-down menu, click Manual Editor.
In the Condition(s) section, keep Query toggled on, select Is, and leave the text input field empty.
If you want to trigger this rule whenever there is an empty query and for this specific context only, toggle Context on. In the dedicated input field, enter the context “landing”. Without including context as part of the condition, this rule triggers on every empty query.
In the Consequence(s) section, click Add consequence and select Add Query Parameter.
In the input field that appears, enter the JSON search parameter you want to add followed by a colon and the value you want to add. For example:

```json { “optionalFilters”: “clearance:true” }
If you want to forward the rule to replicas or other indices, toggle Copy this rule to other indices, and enter the relevant indices.
Save your changes.

In JSON, you must write string values inside quotation marks, and number values and booleans without quotations. For more information about JSON syntax, see What is in a record.

Did you find this page helpful?

Merchandising on empty queries

On this page

Using the API

Using the Visual Editor

Using the Manual Editor

On this page