Adding Search Parameters Dynamically

Dataset Example

Back to the airports example. Imagine we have the following dataset:

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
[
  {
    "name": "Orly",
    "city": "Paris",
    "country": "France",
    "_geoloc": { "lat": 48.725278, "lng": 2.359444 },
    "nb_airline_liaisons": 404
  },
  {
    "name": "Charles De Gaulle",
    "city": "Paris",
    "country": "France",
    "_geoloc": { "lat": 49.012779, "lng": 2.55 },
    "nb_airline_liaisons": 1041
  },
  {
    "name": "Le Bourget",
    "city": "Paris",
    "country": "France",
    "_geoloc": { "lat": 48.961487, "lng": 2.436966 },
    "nb_airline_liaisons": 0
  },
  {
    "name": "Ben Gurion",
    "city": "Tel-Aviv",
    "country": "Israel",
    "_geoloc": { "lat": 32.011389, "lng": 34.886667 },
    "nb_airline_liaisons": 271
  },
  {
    "name": "Haifa",
    "city": "Haifa",
    "country": "Israel",
    "_geoloc": { "lat": 32.809444, "lng": 35.043056 },
    "nb_airline_liaisons": 4
  },
  {
    "name": "Pudong",
    "city": "Shanghai",
    "country": "China",
    "_geoloc": { "lat": 31.143378, "lng": 121.805214 },
    "nb_airline_liaisons": 825
  },
  {
    "name": "Hongqiao Intl",
    "city": "Shanghai",
    "country": "China",
    "_geoloc": { "lat": 31.197875, "lng": 121.336319 },
    "nb_airline_liaisons": 411
  }
]

The first thing we could do is use nb_airline_liaisons for custom ranking, so we prioritize airports with many liaisons. Yet, as soon as we set aroundLatLngViaIP to true in our search code, this custom ranking would be overridden in favor of geographical proximity, which is part of ranking formula.

For example, we would still have the Paris problem because Le Bourget, even if it has the lowest number of liaisons, has the closest geo proximity to the user.

Other examples: if a user is in Paris and searches for “israel”, they would first get Haifa airport, because this is the Israeli airport that’s the closest to Paris. Yet, it wouldn’t make sense, as Haifa airport is relatively small. “Ben Gurion” is a better choice. Same goes if they were looking for “shanghai”. Hongqiao airport is geographically closer to Paris, but not as big as Pudong airport, which is only 30 km away from Hongqiao.

We can fix this by setting a rule that detects searches for a specific city or country and disables aroundLatLngViaIP as a consequence. Whenever a user specifically looks for a city or country name, like “paris”, “israel”, or “shanghai”, the distance-based search would be disabled, falling back on custom ranking by number of liaisons.

Using the API

To achieve this, you first need to use nb_airline_liaisons for custom ranking. You also need to set city and country as attributes for faceting, so we can detect whenever a query matches any of them.

1
2
3
4
5
6
7
$index->setSettings([
  'customRanking' => [
    'desc(nb_airline_liaisons)'
  ],
  'attributesForFaceting' => [
    'city', 'country'
]);

1
2
3
4
5
6
7
8
index.set_settings({
  customRanking: [
    'desc(nb_airline_liaisons)'
  ],
  attributesForFaceting: [
    'city', 'country'
  ]
})

1
2
3
4
5
6
index.setSettings({
  customRanking: [
    'desc(nb_airline_liaisons)'
  ],
  attributesForFaceting: ['city, country']
});

1
2
3
4
5
6
7
8
9
index.set_settings({
    'customRanking': [
        'desc(nb_airline_liaisons)'
    ],
    'attributesForFaceting': [
        'city',
        'country'
    ]
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
IndexSettings settings = new IndexSettings
{
    AttributesForFaceting = new List<string>
    {
      "city",
      "country"
    },
    CustomRanking = new List<string>
    {
      "desc(nb_airline_liaisons)"
    }
};

index.SetSettings(settings);

// Asynchronous
await index.SetSettingsAsync(settings);

1
2
3
4
5
6
7
8
9
index.setSettings(
  new IndexSettings()
    .setCustomRanking(Collections.singletonList(
      "desc(nb_airline_liaisons)"
    ))
    .setAttributesForFaceting(Arrays.asList(
      "city", "country"
    ))
);

1
2
3
4
res, err := index.SetSettings(search.Settings{
  CustomRanking:         opt.CustomRanking("desc(nb_airline_liaisons)"),
  AttributesForFaceting: opt.AttributesForFaceting("city", "country"),
})

1
2
3
4
5
6
7
8
9
10
11
client.execute {
  changeSettings of "myIndex" `with` IndexSettings(
    customRanking = Some(Seq(
      CustomRanking.desc("nb_airline_liaisons")
    )),
    attributesForFaceting = Some(Seq(
      "city",
      "country"
    ))
  )
}

1
2
3
4
5
6
7
8
9
10
11
val settings = settings {
    customRanking {
        +Desc("nb_airline_liaisons")
    }
    attributesForFaceting {
        +"city"
        +"country"
    }
}

index.setSettings(settings)

Then, you can set a query rule that detects matches in facets city and country, and changes the search parameters accordingly. For this, you need to use the batchRules method.

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
$index->saveRules([
  [
    'objectID' => 'country',
    'condition' => [
      'pattern' => '{facet:country}',
      'anchoring' => 'contains'
    ],
    'consequence' => [
      'params' => [
        'aroundLatLngViaIP' => false
      ]
    ]
  ],
  [
    'objectID' => 'city',
    'condition' => [
      'pattern' => '{facet:city}',
      'anchoring' => 'contains'
    ],
    'consequence' => [
      'params' => [
        'aroundLatLngViaIP' => false
      ]
    ]
  ]
]);

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
index.batch_rules([
  {
    objectID: 'country',
    condition: {
      pattern: '{facet:country}',
      anchoring: 'contains'
    },
    consequence: {
      params: {
        aroundLatLngViaIP: false
      }
    }
  },
  {
    objectID: 'city',
    condition: {
      pattern: '{facet:city}',
      anchoring: 'contains'
    },
    consequence: {
      params: {
        aroundLatLngViaIP: false
      }
    }
  }
])

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
index.batchRules([
  {
    objectID: 'country',
    condition: {
      pattern: '{facet:country}',
      anchoring: 'contains'
    },
    consequence: {
      params: {
        aroundLatLngViaIP: false
      }
    }
  },
  {
    objectID: 'city',
    condition: {
      pattern: '{facet:city}',
      anchoring: 'contains'
    },
    consequence: {
      params: {
        aroundLatLngViaIP: false
      }
    }
  }
]);

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
index.save_rules([
    {
        'objectID': 'country',
        'condition': {
            'pattern': '{facet:country}',
            'anchoring': 'contains'
        },
        'consequence': {
            'params': {
                'aroundLatLngViaIP': False
            }
        }
    },
    {
        'objectID': 'city',
        'condition': {
            'pattern': '{facet:city}',
            'anchoring': 'contains'
        },
        'consequence': {
            'params': {
                'aroundLatLngViaIP': False
            }
        }
    }
])

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
28
29
30
var rule1 = new Rule
{
  ObjectID = "country",
  Condition = new Condition { Anchoring = "contains", Pattern = "{facet:country}" },
  Consequence = new Consequence
  {
    Params = new ConsequenceParams
    {
        AroundLatLngViaIP = false
    }
  }
};

var rule2 = new Rule
{
  ObjectID = "city",
  Condition = new Condition { Anchoring = "contains", Pattern = "{facet:city}" },
  Consequence = new ConsequenceParams
  {
    Params = new ConsequenceParams
    {
        AroundLatLngViaIP = false
    }
  }
};

index.SaveRules(new List<Rule> { rule1, rule2 });

// Asynchronous
await index.SaveRulesAsync(new List<Rule> { rule1, rule2 });

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ConsequenceParams params = new ConsequenceParams();
params.setAroundLatLngViaIP(false);

index.saveRules(
    Arrays.asList(
        new Rule()
            .setObjectID("country")
            .setCondition(
                new Condition().setPattern("{facet:country}").setAnchoring("contains"))
            .setConsequence(new Consequence().setParams(params)),
        new Rule()
            .setObjectID("city")
            .setCondition(new Condition().setPattern("{facet:city}").setAnchoring("contains"))
            .setConsequence(new Consequence().setParams(params))));

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
rules := []search.Rule{
	{
		ObjectID:  "country",
		Condition: search.RuleCondition{Anchoring: search.Contains, Pattern: "{facet:country}"},
		Consequence: search.RuleConsequence{
			Params: &search.RuleParams{
				QueryParams: search.QueryParams{
					AroundLatLngViaIP: opt.AroundLatLngViaIP(true),
				},
			},
		},
	},
	{
		ObjectID:  "city",
		Condition: search.RuleCondition{Anchoring: search.Contains, Pattern: "{facet:city}"},
		Consequence: search.RuleConsequence{
			Params: &search.RuleParams{
				QueryParams: search.QueryParams{
					AroundLatLngViaIP: opt.AroundLatLngViaIP(true),
				},
			},
		},
	},
}

res, err := index.SaveRules(rules)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
client.execute {
  save rules Seq(
    Rule(
      objectID = "country",
      condition = Condition(
        pattern = "{facet:country}",
        anchoring = "contains"
      ),
      consequence = Consequence(
        params = Some(Map("aroundLatLngViaIP" -> true))
      )
    ),
    Rule(
      objectID = "city",
      condition = Condition(
        pattern = "{facet:city}",
        anchoring = "contains"
      ),
      consequence = Consequence(
        params = Some(Map("aroundLatLngViaIP" -> true))
      )
    )
  ) inIndex "myIndex"
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
val country = Attribute("country")
val city = Attribute("city")
val rules = listOf(
    Rule(
        objectID = ObjectID("country"),
        condition = Condition(Anchoring.Contains, Pattern.Facet(country)),
        consequence = Consequence(
            query = Query(aroundLatLngViaIP = false)
        )
    ),
    Rule(
        objectID = ObjectID("city"),
        condition = Condition(Anchoring.Contains, Pattern.Facet(city)),
        consequence = Consequence(
            query = Query(aroundLatLngViaIP = false)
        )
    )
)

index.saveRules(rules)

Using the Dashboard

You can also add your rules in your Algolia dashboard.

Custom ranking

1. Go to your dashboard and select your target index.
2. Click on the Configuration tab.
3. In the Ranking and Sorting section, click the “Add a Custom Ranking” button and select the nb_airline_liaisons attribute from the dropdown.
4. In the Facets subsection of Filtering and Faceting, click the “Add an attribute” button and select the country and city attributes from the dropdown.
5. Save your changes.

Query Rules

1. Go to the Query Rules tab.
2. Click the “New rule” button.
3. In the Condition section:
   • Set the anchoring of “if the query…” to Contains.
   • Type {facet:country} in the input field and press enter.
4. In the Consequences section:
   • Click the “Add consequence” button and select Add Query Parameter.
   • In the Custom JSON Data panel that shows up, add the data you want to return when your user’s query matches the rule: { "aroundLatLngViaIP": false }
5. Click Save.
6. Click the “New rule” button again.
7. In the Condition section:
   • Set the anchoring of “if the query…” to Contains.
   • Type {facet:city} in the input field and press enter.
8. In the Consequences section:
   • Click the “Add consequence” button and select Add Query Parameter.
   • In the Custom JSON Data panel that shows up, add the data you want to return when your user’s query matches the rule: { "aroundLatLngViaIP": false }
9. Click Save.

Query time

Once your rule is ready, you can search for airports, cities, and countries. When the query exactly matches a city or a country from your dataset, the rule sets aroundLatLngViaIP to false regardless of the parameters you set in the query.

Therefore, when a user searches for “paris” or “china”, matching airports are ranked by nb_airline_liaisons. When not searching for either a city or a country, airports are ranked by distance to the user’s current location.

1
2
3
$results = $index->search('query', [
  'aroundLatLngViaIP' => true
]);

1
2
3
results = index.search('query', {
  aroundLatLngViaIP: true
})

1
2
3
4
5
index.search({
  aroundLatLngViaIP: true
}).then(res => {
  // console.log(res);
});

1
2
3
results = index.search('query', {
    'aroundLatLngViaIP': True
})

1
2
3
4
5
6
let query = Query(query: "query")
query.aroundLatLngViaIP = true

index.search(query, completionHandler: { (res, error) in
  print(res)
})

1
2
3
4
index.search(
  new Query("query").setAroundLatLngViaIP(true)
);

1
2
3
index.Search( new Query("query") {
    AroundLatLngViaIP = false
)};

1
2
3
4
5
index.search(
  new Query("query")
    .setAroundLatLngViaIP(true),
  new RequestOptions()
    .addExtraHeader("X-Forwarded-For", "94.228.178.246"));

1
2
3
4
res, err := index.Search(
  "query",
  opt.AroundLatLngViaIP(true),
)

1
2
3
4
5
6
client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    aroundLatLngViaIP = Some(true)
  )
}