attributesToRetrieve

1
2
3
4
5
6
7
index.set_settings({
  attributesToRetrieve: [
    'author',
    'title',
    'content'
  ]
})

1
2
3
4
5
6
7
index.setSettings({
  attributesToRetrieve: [
    'author',
    'title',
    'content'
  ]
});

1
2
3
4
5
6
7
index.set_settings({
    'attributesToRetrieve': [
        'author',
        'title',
        'content'
    ]
})

1
2
3
4
5
6
7
8
9
10
11
12
let settings = Settings()
  .set(\.attributesToRetrieve, to: [
    "author",
    "title",
    "content"
  ])

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

1
2
index.setSettings(new JSONObject().put("attributesToRetrieve",
  new JSONArray().put("author").put("title").put("content")));

1
2
3
4
IndexSettings settings = new IndexSettings
{
    AttributesToRetrieve = new List<string> { "author", "title", "content" }
};

1
2
3
4
5
6
7
index.setSettings(
  new IndexSettings().setAttributesToRetrieve(Arrays.asList(
    "author",
    "title",
    "content"
  ))
);

1
2
3
4
5
6
7
res, err := index.SetSettings(search.Settings{
  AttributesToRetrieve: opt.AttributesToRetrieve(
    "author",
    "title",
    "content",
  ),
})

1
2
3
4
5
6
7
8
9
client.execute {
  changeSettings of "myIndex" `with` IndexSettings(
    attributesToRetrieve = Some(Seq(
      "author",
      "title",
      "content"
    ))
  )
}

1
2
3
4
5
6
7
8
9
val settings = settings {
    attributesToRetrieve {
        +"author"
        +"title"
        +"content"
    }
}

index.setSettings(settings)

1
2
3
4
5
index.set_settings({
  attributesToRetrieve: [
    '*'
  ]
})

1
2
3
4
5
6
7
index.setSettings({
  attributesToRetrieve: [
    '*'
  ]
}).then(() => {
  // done
});

1
2
3
4
5
index.set_settings({
    'attributesToRetrieve': [
        '*'
    ]
})

1
2
3
4
5
6
7
8
let settings = Settings()
  .set(\.attributesToRetrieve, to: ["*"])

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

1
2
index.setSettings(new JSONObject().put("attributesToRetrieve",
  new JSONArray().put("*")));

1
2
3
4
IndexSettings settings = new IndexSettings
{
    AttributesToRetrieve = new List<string> { "*" }
};

1
2
3
4
5
index.setSettings(
  new IndexSettings().setAttributesToRetrieve(Collections.singletonList(
    "*"
  ))
);

1
2
3
4
5
res, err := index.SetSettings(search.Settings{
  AttributesToRetrieve: opt.AttributesToRetrieve(
    "*",
  ),
})

1
2
3
4
5
client.execute {
  changeSettings of "myIndex" `with` IndexSettings(
    replaceSynonymsInHighlight = Some(false)
  )
}

1
2
3
4
5
val settings = settings {
    attributesToRetrieve { +"*" }
}

index.setSettings(settings)

1
2
3
4
5
6
results = index.search('query', {
  attributesToRetrieve: [
    'title',
    'content'
  ]
})

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

1
2
3
4
5
6
results = index.search('query', {
    'attributesToRetrieve': [
        'title',
        'content'
    ]
})

1
2
3
4
5
6
7
8
9
10
11
let query = Query("query")
  .set(\.attributesToRetrieve, to: [
    "title",
    "content"
  ])

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

1
index.search(new Query("query").setAttributesToRetrieve("title", "content"));

1
2
3
4
IndexSettings settings = new IndexSettings
{
    AttributesToRetrieve = new List<string> { "title", "content" }
};

1
2
3
4
5
6
index.search(
  new Query("query").setAttributesToRetrieve(Arrays.asList(
    "title",
    "content"
  ))
);

1
2
3
4
5
6
res, err := index.Search("query", search.Settings{
  AttributesToRetrieve: opt.AttributesToRetrieve(
    "title",
    "content",
  ),
})

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

1
2
3
4
5
6
7
8
val query = query("query") {
    attributesToRetrieve {
        +"title"
        +"content"
    }
}

index.search(query)

1
2
3
4
5
6
7
index.set_settings({
  attributesToRetrieve: [
    '*',
    '-SKU',
    '-internal_desc'
  ]
})

1
2
3
4
5
6
7
8
9
index.setSettings({
  attributesToRetrieve: [
    '*',
    '-SKU',
    '-internal_desc'
  ]
}).then(() => {
  // done
});

1
2
3
4
5
6
7
index.set_settings({
    'attributesToRetrieve': [
        '*',
        '-SKU',
        '-internal_desc'
    ]
})

1
2
3
4
5
6
7
8
9
10
11
12
let settings = Settings()
  .set(\.attributesToRetrieve, to: [
    "*",
    "-SKU",
    "-internal_desc"
  ])

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

1
2
index.setSettings(new JSONObject().put("attributesToRetrieve",
  new JSONArray().put("*").put("-SKU").put("-internal_desc")));

1
2
3
4
IndexSettings settings = new IndexSettings
{
    AttributesToRetrieve = new List<string> { "*", "-SKU", "-internal_desc" }
};

1
2
3
4
5
6
7
index.setSettings(
  new IndexSettings().setAttributesToRetrieve(Arrays.asList(
    "*",
    "-SKU",
    "-internal_desc"
  ))
);

1
2
3
4
5
6
7
res, err := index.SetSettings(search.Settings{
  AttributesToRetrieve: opt.AttributesToRetrieve(
    "*",
    "-SKU",
    "-internal_desc",
  ),
})

1
2
3
4
5
6
7
8
9
client.execute {
  changeSettings of "myIndex" `with` IndexSettings(
    attributesToRetrieve = Some(Seq(
      "*",
      "-SKU",
      "-internal_desc"
    ))
  )
}

1
2
3
4
5
6
7
8
9
val settings = settings {
    attributesToRetrieve {
        +"sku"
        +"internal_desc"
        excludeAttributes = true
    }
}

index.setSettings(settings)