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. Note, to trigger this Rule, you must send landing as a ruleContexts on the front end.

As soon as user begins typing, we disable the Rule. If you want a Rule that is always active for a particular context regardless of the query string, create a Rule with context as the only condition. Our guide on using Rules to customize search results by platform shows how to create context based rules.

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. It’s necessary to use either filters or context in the Rule conditions to differentiate between which category pages should trigger these Rules.

In depth Category Pages

Merchandise Category Pages

How to Use the Visual Editor for Merchandising 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
15
16
17
18
19
20
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"
}

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)

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 dropdown, click on the Visual Editor option.
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.
Before exiting, don’t forget to 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 dropdown, click on the Manual Editor option.
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 on 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:
Copy
1 2 3 { "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.
Don’t forget to save your changes.

In JSON, you must write string values inside quotation marks, and number values and booleans without quotations. To get further details on JSON syntax, checkout our page on record structure.

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