CRUD - Ler - React Native SDK

Nesta página

Encontrar um objeto específico por chave primária

query para um tipo de objeto e resultados de filtro
query para um tipo de objeto e classificação de resultados

Os Atlas Device SDKs estão obsoletos. Consulte apágina de descontinuação do para detalhes.

Operações de leitura são queries para encontrar seus dados armazenados no Realm. Os dados em Realm são ativos, o que significa que um objeto sempre reflete seu estado salvo mais recente e as operações de leitura nunca bloqueiam. Os objetos são atualizados automaticamente em resposta às alterações, para que você possa ver dados atualizados em seu aplicativo sem executar uma nova query.

Use os seguintes @realm/react ganchos para ler dados em um domínio:

useObject(): Encontre um objeto específico por chave primária.
useQuery(): Obtenha uma coleção de objetos por tipo de objeto.

Esses ganchos retornam objetos ativos, que são atualizados automaticamente quando os dados no domínio mudam. Quando os objetos retornados por esses ganchos são atualizados, o componente que chama o gancho é renderizado novamente.

Os exemplos nesta página usam os seguintes esquemas:

class Person extends Realm.Object {
  static schema = {
    name: 'Person',
    properties: {
      name: 'string',
      age: 'int?',
    },
  };
}

class Task extends Realm.Object {
  static schema = {
    name: 'Task',
    properties: {
      _id: 'int',
      name: 'string',
      priority: 'int?',
      progressMinutes: 'int?',
      assignee: 'Person?',
    },
    primaryKey: '_id',
  };
}

class Person extends Realm.Object<Person> {
  name!: string;
  age?: number;
  static schema: ObjectSchema = {
    name: 'Person',
    properties: {
      name: 'string',
      age: 'int?',
    },
  };
}

class Task extends Realm.Object<Task> {
  _id!: number;
  name!: string;
  priority?: number;
  progressMinutes?: number;
  assignee?: Person;
  age?: number;
  static schema: ObjectSchema = {
    name: 'Task',
    properties: {
      _id: 'int',
      name: 'string',
      priority: 'int?',
      progressMinutes: 'int',
      assignee: 'Person?',
    },
    primaryKey: '_id',
  };
}

Encontrar um objeto específico por chave primária

Se você souber a chave primária de um determinado objeto, poderá procurá-la diretamente passando o tipo de classe e a chave primária para o gancho useObject().

No exemplo a seguir de um componente TaskItem, usamos o gancho useObject() para encontrar uma tarefa com base em sua chave primária: _id. Em seguida, renderizamos o nome e a prioridade da tarefa na interface do usuário.

const TaskItem = ({_id}) => {
  const myTask = useObject(Task, _id);
  return (
    <View>
      {myTask ? (
        <Text>
          {myTask.name} is a task with the priority of: {myTask.priority}
        </Text>
      ) : null}
    </View>
  );
};

const TaskItem = ({_id}: {_id: number}) => {
  const myTask = useObject(Task, _id);
  return (
    <View>
      {myTask ? (
        <Text>
          {myTask.name} is a task with the priority of: {myTask.priority}
        </Text>
      ) : null}
    </View>
  );
};

query para um tipo de objeto e resultados de filtro

O gancho useQuery() retorna uma coleção de objetos do Realm que correspondem à query como um objeto doRealm .Results . Uma query básica corresponde a todos os objetos de um determinado tipo em um Realm, mas você também pode aplicar um filtro à coleção para localizar objetos específicos.

Um filtro seleciona um subconjunto de resultados com base nos valores de uma ou mais propriedades do objeto. O Realm permite filtrar dados usando a Realm Query Language, uma linguagem de query baseada em strings para restringir as pesquisas ao recuperar objetos de um domínio.

Chame filtered() na coleção de resultados da query para filtrar uma query. Passe uma query RQL como argumento para filtered().

No exemplo a seguir de um componente TaskList , nós:

Obtenha todos os Task objetos passando "Tarefa" para o gancho useQuery().
Obtenha todas as tarefas de alta prioridade e tarefas de baixa prioridade passando uma query para filtered().
Use a função de mapa para renderizar uma lista de componentes de texto exibindo informações sobre as tarefas de alta prioridade e de baixo progresso.

const TaskList = () => {
  const [priority, setPriority] = useState(4);
  // filter for tasks with a high priority
  const highPriorityTasks = useQuery(
    Task,
    (tasks) => {
      return tasks.filtered("priority >= $0", priority);
    },
    [priority]
  );
  // filter for tasks that have just-started or short-running progress
  const lowProgressTasks = useQuery(Task, tasks => {
    return tasks.filtered(
      '$0 <= progressMinutes && progressMinutes < $1',
      1,
      10,
    );
  });
  return (
    <>
      <Text>Your high priority tasks:</Text>
      {highPriorityTasks.map(taskItem => {
        return <Text>{taskItem.name}</Text>;
      })}
      <Text>Your tasks without much progress:</Text>
      {lowProgressTasks.map(taskItem => {
        return <Text>{taskItem.name}</Text>;
      })}
    </>
  );
};

const TaskList = () => {
  const [priority, setPriority] = useState(4);
  // filter for tasks with a high priority
  const highPriorityTasks = useQuery(
    Task,
    tasks => {
      return tasks.filtered('priority >= $0', priority);
    },
    [priority],
  );
  // filter for tasks that have just-started or short-running progress
  const lowProgressTasks = useQuery(Task, tasks => {
    return tasks.filtered(
      '$0 <= progressMinutes && progressMinutes < $1',
      1,
      10,
    );
  });
  return (
    <>
      <Text>Your high priority tasks:</Text>
      {highPriorityTasks.map(taskItem => {
        return <Text>{taskItem.name}</Text>;
      })}
      <Text>Your tasks without much progress:</Text>
      {lowProgressTasks.map(taskItem => {
        return <Text>{taskItem.name}</Text>;
      })}
    </>
  );
};

Dica

Filtrar nas Propriedades de Objetos Relacionados e Embarcados

Para filtrar uma consulta com base na propriedade de um objeto incorporado ou de um objeto relacionado, use a notação de pontos como se estivesse em um objeto normal aninhado.

Dica

Veja também:

query para um tipo de objeto e classificação de resultados

Uma operação de classificação permite a você configurar a ordem na qual o Realm retorna objetos consultados. A classificação pode ser feita com base em uma ou mais propriedades dos objetos na coleção de resultados. O Realm só garante a uniformidade na ordem de resultados se você classificá-los explicitamente.

Para classificar uma consulta, chame o método sorted() na coleção de resultados da consulta.

No exemplo a seguir de um componente TaskList, usamos o gancho useQuery() para recuperar inicialmente o conjunto de objetos de tarefa. Em seguida, usamos o método sorted() para trabalhar com os dados de várias maneiras:

Classifique objetos com base no nome da tarefa alfabeticamente.
Classifique objetos com base no nome da tarefa alfabeticamente em ordem decrescente.
Classifique objetos com base na prioridade da tarefa em ordem decrescente e no nome da tarefa em ordem crescente.
Classificar objetos com base no nome do objeto atribuído alfabeticamente.

Finalmente, mapeamos cada lista de tarefas e as entregamos na interface do usuário.

const TaskList = () => {
  // retrieve the set of Task objects
  const tasks = useQuery(Task);
  // Sort tasks by name in ascending order
  const tasksByName = useQuery(Task, tasks => {
    return tasks.sorted('name');
  });
  // Sort tasks by name in descending order
  const tasksByNameDescending = useQuery(Task, tasks => {
    return tasks.sorted('name', true);
  });
  // Sort tasks by priority in descending order and then by name alphabetically
  const tasksByPriorityDescendingAndName = useQuery(Task, tasks => {
    return tasks.sorted([
      ['priority', true],
      ['name', false],
    ]);
  });
  // Sort Tasks by Assignee's name.
  const tasksByAssigneeName = useQuery(Task, tasks => {
    return tasks.sorted('assignee.name');
  });
  return (
    <>
      <Text>All tasks:</Text>
      {tasks.map(task => (
        <Text>{task.name}</Text>
      ))}
      <Text>Tasks sorted by name:</Text>
      {tasksByName.map(task => (
        <Text>{task.name}</Text>
      ))}
      <Text>Tasks sorted by name descending:</Text>
      {tasksByNameDescending.map(task => (
        <Text>{task.name}</Text>
      ))}
      <Text>
        Tasks sorted by priority descending, and name alphabetically:
      </Text>
      {tasksByPriorityDescendingAndName.map(task => (
        <Text>
          {task.name}
        </Text>
      ))}
      <Text>Tasks sorted by assignee name:</Text>
      {tasksByAssigneeName.map(task => (
        <Text>{task.name}</Text>
      ))}
    </>
  );
};

const TaskList = () => {
  // retrieve the set of Task objects
  const tasks = useQuery(Task);
  // Sort tasks by name in ascending order
  const tasksByName = useQuery(Task, tasks => {
    return tasks.sorted('name');
  });
  // Sort tasks by name in descending order
  const tasksByNameDescending = useQuery(Task, tasks => {
    return tasks.sorted('name', true);
  });
  // Sort tasks by priority in descending order and then by name alphabetically
  const tasksByPriorityDescendingAndName = useQuery(Task, tasks => {
    return tasks.sorted([
      ['priority', true],
      ['name', false],
    ]);
  });
  // Sort Tasks by Assignee's name.
  const tasksByAssigneeName = useQuery(Task, tasks => {
    return tasks.sorted('assignee.name');
  });
  return (
    <>
      <Text>All tasks:</Text>
      {tasks.map(task => (
        <Text>{task.name}</Text>
      ))}
      <Text>Tasks sorted by name:</Text>
      {tasksByName.map(task => (
        <Text>{task.name}</Text>
      ))}
      <Text>Tasks sorted by name descending:</Text>
      {tasksByNameDescending.map(task => (
        <Text>{task.name}</Text>
      ))}
      <Text>
        Tasks sorted by priority descending, and name alphabetically:
      </Text>
      {tasksByPriorityDescendingAndName.map(task => (
        <Text>
          {task.name}
        </Text>
      ))}
      <Text>Tasks sorted by assignee name:</Text>
      {tasksByAssigneeName.map(task => (
        <Text>{task.name}</Text>
      ))}
    </>
  );
};

Dica

Classificar nas Propriedades de Objetos Relacionados e Embarcados

Para classificar uma consulta com base em uma propriedade de um objeto incorporado ou de um objeto relacionado, use não anotação como se estivesse em um objeto aninhado regular.

Voltar

criar

Update