filters

1
2
3
index.search('query', {
  filters: '(category:Book OR category:Ebook) AND _tags:published'
})

1
2
3
4
5
index.search('query', {
  filters: '(category:Book OR category:Ebook) AND _tags:published'
}).then({ hits } => {
  console.log(hits);
});

1
2
3
index.search('query', {
    'filters': '(category:Book OR category:Ebook) AND _tags:published'
})

1
2
3
4
5
6
7
8
let query = Query("query")
  .set(\.filters, to: "(category:Book OR category:Ebook) AND _tags:published")

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
index.Search<Book>(new Query("query")
{
    Filters = "(category:Book OR category:Ebook) AND _tags:published"
});

1
2
3
4
index.search(
  new Query("query")
    .setFilters("(category:Book OR category:Ebook) AND _tags:published")
);

1
2
3
4
res, err := index.Search(
  "query",
  opt.Filters("(category:Book OR category:Ebook) AND _tags:published"),
)

1
2
3
4
5
6
client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    filters = Some("(category:Book OR category:Ebook) AND _tags:published")
  )
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// "(category:Book OR category:Ebook) AND _tags:published"
val query = query("query") {
    filters {
        orFacet {
            facet("category", "Book")
            facet("category", "Ebook")
        }
        and {
            tag("published")
        }
    }
}

index.search(query)

1
2
3
4
5
filters = 'available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:"John Doe"'

index.search('query', {
  filters: filters
})

1
2
3
4
5
6
7
const filters = 'available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:"John Doe"';

index.search('query', {
  filters: filters
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
4
5
filters = "available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:\"John Doe\""

index.search('query', {
    'filters': filters
})

1
2
3
4
5
6
7
8
let query = Query("query")
  .set(\.filters, to: "available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:\"John Doe\"")

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
string filters = "available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:\"John Doe\"";

index.Search<Book>(new Query("query")
{
    Filters = filters
});

1
2
3
4
5
6
7
8
9
10
11
12
13
String filters = new String(
  "available = 1"
  + " AND (category:Book OR NOT category:Ebook)"
  + " AND _tags:published"
  + " AND publication_date:1441745506 TO 1441755506"
  + " AND inStock > 0"
  + " AND author:\"John Doe\""
);

index.search(
  new Query("query")
    .setFilters(filters)
);

1
2
3
4
5
filters := opt.Filters(
  "available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:\"John Doe\"",
)

res, err := index.Search("query", filters)

1
2
3
4
5
6
7
8
val filters = Some("available = 1 AND (category:Book OR NOT category:Ebook) AND _tags:published AND publication_date:1441745506 TO 1441755506 AND inStock > 0 AND author:\"John Doe\"")

client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    filters = filters
  )
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//  available = 1
//  AND (category:Book OR NOT category:Ebook)
//  AND _tags:published
//  AND publication_date:1441745506 TO 1441755506
//  AND inStock > 0
//  AND author:\"John Doe\"";
val query = query("query") {
    filters {
        and {
            comparison("available", Equals, 1)
            tag("published")
            range("publication_date", 1441745506..1441755506)
            comparison("inStock", NumericOperator.Greater, 0)
            facet("author", "John Doe")
        }
        orFacet {
            facet("category", "Book")
            facet("category", "EBook", isNegated = true)
        }
    }
}

index.search(query)

1
2
3
index.search('query', {
  filters: "category:'Books and Comics'"
})

1
2
3
4
5
index.search('query', {
  filters: 'category:"Books and Comics"'
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
index.search('query', {
    'filters': "category:'Books and Comics'"
})

1
2
3
4
5
6
7
8
let query = Query("query")
  .set(\.filters, to: "category:'Books and Comics'")

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
index.Search<Book>(new Query("query")
{
    Filters = "category:'Books and Comics'"
});

1
2
3
4
index.search(
  new Query("query")
    .setFilters("category:'Books and Comics'")
);

1
2
3
4
res, err := index.Search(
  "query",
  opt.Filters("category:'Books and Comics'"),
)

1
2
3
4
5
6
client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    filters = Some("category:'Books and Comics'")
  )
}

1
2
3
4
5
6
7
8
9
10
11
// "\"category\":\"Books and Comics\""
val query = query("query") {
    filters {
        and {
            // You don't have to escape strings, it is done for you.
            facet("category", "Books and Comics")
        }
    }
}

index.search(query)

1
2
3
index.search('query', {
  filters: "keyword:'OR'"
})

1
2
3
4
5
index.search('query', {
  filters: 'keyword:"OR"'
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
index.search('query', {
    'filters': "keyword:'OR'"
})

1
2
3
4
5
6
7
8
let query = Query("query")
  .set(\.filters, to: "keyword:'OR'")

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
index.Search<Book>(new Query("query")
{
    Filters = "keyword:'OR'"
});

1
2
3
4
index.search(
  new Query("query")
    .setFilters("keyword:'OR'")
);

1
2
3
4
res, err := index.Search(
  "query",
  opt.Filters("keyword:'OR'"),
)

1
2
3
4
5
6
client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    filters = Some("keyword:'OR'")
  )
}

1
2
3
4
5
6
7
8
9
10
11
// "\"keyword\":\"OR\""
val query = query("query") {
    filters {
        and {
            // You don't have to escape keywords, it is done for you.
            facet("keyword", "OR")
        }
    }
}

index.search(query)

1
2
3
index.search('query', {
  filters: "content:'It\\'s a wonderful day'"
})

1
2
3
4
5
index.search('query', {
  filters: 'content:"It\'s a wonderful day"'
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
index.search('query', {
    'filters': "content:'It\\'s a wonderful day'"
})

1
2
3
4
5
6
7
8
let query = Query("query")
  .set(\.filters, to: "content:'It\\'s a wonderful day'")

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
index.Search<Book>(new Query("query")
{
    Filters = "content:'It\\'s a wonderful day'"
});

1
2
3
4
index.search(
  new Query("query")
    .setFilters("content:'It\\'s a wonderful day'")
);

1
2
3
4
res, err := index.Search(
  "query",
  opt.Filters("content:'It\\'s a wonderful day'"),
)

1
2
3
4
5
6
client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    filters = Some("content:'It\\'s a wonderful day'")
  )
}

1
2
3
4
5
6
7
8
9
10
11
// "\"content\":\"It's a wonderful day\""
val query = query("query") {
    filters {
        and {
          // You don't have to escape single quotes, it is done for you.
            facet("content", "It's a wonderful day")
        }
    }
}

index.search(query)

1
2
3
index.search('query', {
  filters: "content:'She said \"Hello World\"'"
})

1
2
3
4
5
index.search('query', {
  filters: 'content:"She said \\"Hello World\\""'
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
index.search('query', {
    'filters': "content:'She said \"Hello World\"'"
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
index.Search<Book>(new Query("query")
{
    Filters = "content:'She said \"Hello World\"'"
});

  swift: |

let query = Query("query")
  .set(\.filters, to: "content:'She said \"Hello World\"'")

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
index.search(
  new Query("query")
    .setFilters("content:'She said \"Hello World\"'")
);

1
2
3
4
res, err := index.Search(
  "query",
  opt.Filters("content:'She said \"Hello World\"'"),
)

1
2
3
4
5
6
client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    filters = Some("content:'She said \"Hello World\"'")
  )
}

1
2
3
4
5
6
7
8
9
10
// "\"content\":\"She said Hello World\""
val query = query("query") {
    filters {
        and {
            facet("content", "She said \"Hello World\"")
        }
    }
}

index.search(query)