---
title: EntitiesByNameQuery
source: https://docs.newrelic.com/docs/new-relic-solutions/build-nr-ui/sdk-component/query-and-storage/EntitiesByNameQuery
---

Query entities by their name.

### Usage

```jsx
import { EntitiesByNameQuery } from 'nr1'
```

### Examples

#### Declarative query

```jsx
<EntitiesByNameQuery name="abc1-prod-metrics">
  {({ loading, error, data, fetchMore }) => {
    if (error) {
      return 'Error!';
    }

    return (
      <List
        items={data.entities}
        rowCount={data.count}
        rowHeight={20}
        onLoadMore={fetchMore}
      >
        {({ item }) => <ListItem key={item.guid}>{item.name}</ListItem>}
      </List>
    );
  }}
</EntitiesByNameQuery>
```

#### Fetch with sorting criteria

```jsx
<EntitiesByNameQuery 
  name="abc1-prod-metrics"
  sortType={[EntitiesByNameQuery.SORT_TYPE.ALERT_SEVERITY]}
>
  {({ loading, error, data, fetchMore }) => {
    if (error) {
      return 'Error!';
    }

    return (
      <List
        items={data.entities}
        rowCount={data.count}
        rowHeight={20}
        onLoadMore={fetchMore}
      >
        {({ item }) => <ListItem key={item.guid}>{item.name}</ListItem>}
      </List>
    );
  }}
</EntitiesByNameQuery>
```

#### Imperative query

```js
EntitiesByNameQuery.query({
  name: 'abc1-prod-metrics',
}).then(({ data }) => console.log(data));
```

#### Fetch more results using imperative query

```js
const name = 'abc1-prod-metrics';
const firstPage = await EntitiesByNameQuery.query({ name });

console.log('First page data', firstPage.data);

const cursor = firstPage.data.nextCursor;
const secondPage = await EntitiesByNameQuery.query({ cursor, name });

console.log('Second page data', secondPage.data);

// NOTE: To fetch multiple page results consecutively, use EntitiesByNameQuery
// component's fetchMore approach.
```

### Props

| `children` function                        | Render prop function as a child.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| ------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `entityFragmentExtension` object           | GraphQL fragment document parsed into an AST by `graphql-tag`.The Query components return the most commonly used fields available on an entity. You can use this prop when you want to request additional fields for the entities returned by your query.The fragment should be named `EntityFragmentExtension` and apply to the `EntityOutline` type. ````js const entityFragmentExtension = ngql`   fragment EntityFragmentExtension on EntityOutline {     indexedAt     guid   } `; ```  ````                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| `fetchPolicyType` enum                     | Allows you to specify how you want your query to interact with the cached data. - `CACHE_AND_NETWORK`: The query returns your initial data from the cache if available. However, regardless of whether or not the full data is in your cache, the query always makes a request using your network interface and returns the updated data. This option is not available when using the static `query()` method of the component. - `CACHE_FIRST`: The query makes a request using your network interface **only** if the data for your query is not already in the cache. - `CACHE_ONLY`: The query **never** makes a request using your network interface. Instead it returns the data available in the cache. If the data for your query does not exist in the cache, then an error is thrown. - `NETWORK_ONLY`: The query **never** returns your initial data from the cache. Instead it **always** makes a request using your network interface. - `NO_CACHE`: The query **never** returns your initial data from the cache. Instead it **always** makes a request using your network interface. Unlike the `NETWORK_ONLY` policy, it does not write any data to the cache after the query completes. EntitiesByNameQuery.FETCH_POLICY_TYPE.CACHE_AND_NETWORK, EntitiesByNameQuery.FETCH_POLICY_TYPE.CACHE_FIRST, EntitiesByNameQuery.FETCH_POLICY_TYPE.CACHE_ONLY, EntitiesByNameQuery.FETCH_POLICY_TYPE.NETWORK_ONLY, EntitiesByNameQuery.FETCH_POLICY_TYPE.NO_CACHE, |
| `filters` string\|(shape\|shape\|shape)\[] | Filters used to narrow down the entities.This is an array of filters, and there are 3 possible filters: - SearchQueryFilter: `Object<type: string = "searchQuery", value: string>` - EntityTypeFilter: `Object<type: string = "entityType", Object<domain: string, type: string>>` - TagFilter: `Object<type: string = "tag", Object<key: string, value: string>>` ```js const filters = [   { type: "searchQuery", value: "foo" },   { type: "entityType", value: { domain: "APM", type: "APPLICATION" } },   { type: "tag", value: { key: "environment", value: "production" } },   { type: "tag", value: { key: "team", value: "bar" } }, ]; ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `includeSummaryMetrics` boolean            |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| `includeTags` boolean                      | If `true`, the returned entities include their tags.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| `limit` number                             | Pagination, number of entities to fetch for on each page.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| `name` REQUIREDstring                      | Name or partial name of the entities to query.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| `pollInterval` number                      | Interval in milliseconds to poll for new data. Set to zero to avoid any kind of regular polling.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| `skip` boolean                             | When set to `true`, the query will be skipped entirely from rendering.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| `sortBy` DEPRECATED                        | > #### ⚠️ DUE NOVEMBER 1ST, 2023 > > The sortBy is deprecated, use sortType instead                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| `sortType` enum\[]                         | Array of criteras used to sort the entity search results. EntitiesByNameQuery.SORT_TYPE.ALERT_SEVERITY, EntitiesByNameQuery.SORT_TYPE.DOMAIN, EntitiesByNameQuery.SORT_TYPE.MOST_RELEVANT, EntitiesByNameQuery.SORT_TYPE.NAME, EntitiesByNameQuery.SORT_TYPE.REPORTING, EntitiesByNameQuery.SORT_TYPE.TYPE,                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |

### Methods

### `EntitiesByNameQuery.query`

### Type definitions