/ /

/ /

SDK de dispositivos Atlas

SDK de React Native

CRUD

CRUD - Leer - SDK de React Native

Los SDK de dispositivos Atlas están obsoletos. Consulte Página de desuso para más detalles.

Las operaciones de lectura son consultas para encontrar los datos almacenados en Realm. Los datos en Realm están activos, lo que significa que un objeto siempre refleja su estado guardado más reciente y las operaciones de lectura nunca se bloquean. Los objetos se actualizan automáticamente en respuesta a los cambios, por lo que puede ver los datos actualizados en su aplicación sin ejecutar una nueva consulta.

Utilice lo siguiente @realm/react Ganchos para leer datos en un reino:

useObject():Busca un objeto específico por clave principal.
useQuery():Obtener una colección de objetos por tipo de objeto.

Estos ganchos devuelven objetos activos, que se actualizan automáticamente cuando cambian los datos del dominio. Cuando se actualizan los objetos devueltos por estos ganchos, el componente que los llama vuelve a renderizarlos.

Los ejemplos de esta página utilizan los siguientes 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',
  };
}

Buscar un objeto específico por clave primaria

Si conoce la clave principal de un objeto determinado, puede buscarla directamente pasando el tipo de clase y la clave principal al useObject() gancho.

En el siguiente ejemplo de un componente TaskItem, usamos el gancho useObject() para encontrar una tarea según su clave principal: _id. A continuación, representamos el nombre y la prioridad de la tarea en la interfaz de usuario.

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>
  );
};

Consulta de un tipo de objeto y filtrado de resultados

El gancho useQuery() devuelve una colección de objetos Realm que coinciden con la consulta como una Objeto Realm.Results. Una consulta básica busca todos los objetos de un tipo determinado en un reino, pero también se puede aplicar un filtro a la colección para encontrar objetos específicos.

Un filtro selecciona un subconjunto de resultados según los valores de una o más propiedades de un objeto. Realm permite filtrar datos mediante el lenguaje de consulta de Realm, un lenguaje de consulta basado en cadenas, para restringir las búsquedas al recuperar objetos de un dominio.

Invoque filtered() en la colección de resultados de la consulta para filtrarla. Pase una consulta del lenguaje de consulta Realm como argumento filtered() a.

En el siguiente ejemplo de un componente TaskList, hacemos lo siguiente:

Obtenga todos los objetos Task pasando "Tarea" al gancho useQuery().
Obtenga todas las tareas de alta prioridad y las tareas de bajo progreso pasando una consulta a filtered().
Utilice la función de mapa para representar una lista de componentes de texto que muestren información sobre las tareas de alta prioridad y bajo progreso.

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>;
      })}
    </>
  );
};

Tip

Filtrar por propiedades de objetos relacionados e incrustados

Para filtrar una consulta en función de una propiedad de un objeto incrustado o un objeto relacionado, utilice la notación de puntos como si se tratara de un objeto anidado normal.

Tip

Consulta de un tipo de objeto y ordenación de resultados

Una operación de ordenación permite configurar el orden en que Realm devuelve los objetos consultados. Puede ordenarlos según una o más propiedades de los objetos de la colección de resultados. Realm solo garantiza un orden consistente de los resultados si los ordena explícitamente.

Para ordenar una consulta, llame al método sorted() en la colección de resultados de la consulta.

En el siguiente ejemplo de un componente TaskList, usamos el gancho useQuery() para recuperar inicialmente el conjunto de objetos de tarea. Luego, usamos el método sorted() para trabajar con los datos de diversas maneras:

Ordenar objetos según el nombre de la tarea alfabéticamente.
Ordenar objetos según el nombre de la tarea alfabéticamente en orden descendente.
Ordene los objetos según la prioridad de la tarea en orden descendente y el nombre de la tarea en orden ascendente.
Ordenar objetos según el nombre del objeto asignado alfabéticamente.

Finalmente, mapeamos cada lista de tareas y las representamos en la interfaz de usuario.

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>
      ))}
    </>
  );
};

Tip

Ordenar por propiedades de objetos relacionados e incrustados

Para ordenar una query basada en una propiedad de un objeto incrustado o un objeto relacionado, usa notación de puntos como si fuera un objeto anidado regular.

Volver

Crear

Update