responseFields

1
2
3
4
5
6
7
8
index.set_settings({
  responseFields: [
    'hits',
    'hitsPerPage',
    'nbPages',
    'page'
  ]
})

1
2
3
4
5
6
7
8
9
10
index.setSettings({
  responseFields: [
    'hits',
    'hitsPerPage',
    'nbPages',
    'page'
  ]
}).then(() => {
  // done
});

1
2
3
4
5
6
7
8
index.set_settings({
    'responseFields': [
        'hits',
        'hitsPerPage',
        'nbPages',
        'page'
    ]
})

1
2
3
4
5
6
7
8
9
10
11
12
13
let settings = Settings()
  .set(\.responseFields, to: [
    .hits,
    .hitsPerPage,
    .nbPages,
    .page
  ])

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

1
2
3
4
5
6
7
8
9
10
11
index.setSettings(
  new JSONObject()
    .put(
      "responseFields",
      new JSONArray()
        .put("hits")
        .put("hitsPerPage")
        .put("nbPages")
        .put("page")
    )
);

1
2
3
4
5
6
7
8
9
10
IndexSettings settings = new IndexSettings();
settings.ResponseFields = new List<string>
{
    "hits",
    "hitsPerPage",
    "nbPages",
    "page"
};

index.SetSettings(settings);

1
2
3
4
5
6
7
8
9
10
11
index.setSettings(
  new IndexSettings()
    .setResponseFields(
      Arrays.asList(
        "hits",
        "hitsPerPage",
        "nbPages",
        "page"
      )
    )
);

1
2
3
4
5
6
7
8
res, err := index.SetSettings(search.Settings{
  ResponseFields: opt.ResponseFields(
    "hits",
    "hitsPerPage",
    "nbPages",
    "page",
  ),
})

1
2
3
4
5
6
7
8
9
10
client.execute {
  changeSettings of "myIndex" `with` IndexSettings(
    responseFields = Some(Seq(
      "hits",
      "hitsPerPage",
      "nbPages",
      "page"
    ))
  )
}

1
2
3
4
5
6
7
8
9
10
val settings = settings {
    responseFields {
        +Hits
        +HitsPerPage
        +NbPages
        +Page
    }
}

index.setSettings(settings)

1
2
3
4
5
6
results = index.search({
  responseFields: [
    'hits',
    'facets'
  ]
})

1
2
3
4
5
6
7
8
index.search('query', {
  responseFields: [
    'hits',
    'facets'
  ]
}).then(({ hits }) => {
  console.log(hits);
});

1
2
3
4
5
6
results = index.search('query', {
    'responseFields': [
        'hits',
        'facets'
    ]
})

1
2
3
4
5
6
7
8
let query = Query("query")
  .set(\.responseFields, to: [.hits, .facets])

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

1
2
3
4
index.search(
  new Query("query")
    .setResponseFields("hits", "facets")
);

1
2
3
4
5
6
7
8
index.Search<T>(new Query("")
{
    ResponseFields = new List<string>
    {
        "hits",
        "facets"
    },
});

1
2
3
4
5
6
7
8
9
index.search(
  new Query("query")
    .setResponseFields(
      Arrays.asList(
        "hits",
        "facets"
      )
    )
);

1
2
3
4
5
6
7
res, err := index.Search(
  "query",
  opt.ResponseFields(
    "hits",
    "facets"
  ),
)

1
2
3
4
5
6
7
8
9
client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    responseFields = Some(Seq(
      "hits",
      "facets"
    ))
  )
}

1
2
3
4
5
6
7
8
val query = query("query") {
    responseFields {
        +Hits
        +Facets
    }
}

index.search(query)