Consulta basada en múltiples cláusulas where en Firebase

{
"movies": {
    "movie1": {
        "genre": "comedy",
        "name": "As good as it gets",
        "lead": "Jack Nicholson"
    },
    "movie2": {
        "genre": "Horror",
        "name": "The Shining",
        "lead": "Jack Nicholson"
    },
    "movie3": {
        "genre": "comedy",
        "name": "The Mask",
        "lead": "Jim Carrey"
    }
  }  
 }

Soy un novato de Firebase. ¿Cómo puedo recuperar un resultado de los datos anteriores donde genre = 'comedy'ANDlead = 'Jack Nicholson' ?

¿Que opciones tengo?

Usando la API de consulta de Firebase , puede tener la tentación de probar esto:

// !!! THIS WILL NOT WORK !!!
ref
  .orderBy('genre')
  .startAt('comedy').endAt('comedy')
  .orderBy('lead')                  // !!! THIS LINE WILL RAISE AN ERROR !!!
  .startAt('Jack Nicholson').endAt('Jack Nicholson')
  .on('value', function(snapshot) { 
      console.log(snapshot.val()); 
  });

Pero como dice @RobDiMarco de Firebase en los comentarios:

múltiples orderBy()llamadas arrojarán un error

Entonces mi código anterior no funcionará .

Sé de tres enfoques que funcionarán.

1. filtrar más en el servidor, hacer el resto en el cliente

Lo que puede hacer es ejecutar uno orderBy().startAt()./endAt()en el servidor, extraer los datos restantes y filtrarlos en el código JavaScript de su cliente.

ref
  .orderBy('genre')
  .equalTo('comedy')
  .on('child_added', function(snapshot) { 
      var movie = snapshot.val();
      if (movie.lead == 'Jack Nicholson') {
          console.log(movie);
      }
  });

2. agregue una propiedad que combine los valores que desea filtrar

Si eso no es lo suficientemente bueno, debería considerar modificar / expandir sus datos para permitir su caso de uso. Por ejemplo: podría incluir género + plomo en una sola propiedad que solo usa para este filtro.

"movie1": {
    "genre": "comedy",
    "name": "As good as it gets",
    "lead": "Jack Nicholson",
    "genre_lead": "comedy_Jack Nicholson"
},...

Básicamente, está creando su propio índice de múltiples columnas de esa manera y puede consultarlo con:

ref
  .orderBy('genre_lead')
  .equalTo('comedy_Jack Nicholson')
  .on('child_added', function(snapshot) { 
      var movie = snapshot.val();
      console.log(movie);
  });

David East ha escrito una biblioteca llamada QueryBase que ayuda a generar tales propiedades .

Incluso podría hacer consultas relativas / de rango, supongamos que desea permitir consultas de películas por categoría y año. Usaría esta estructura de datos:

"movie1": {
    "genre": "comedy",
    "name": "As good as it gets",
    "lead": "Jack Nicholson",
    "genre_year": "comedy_1997"
},...

Y luego consulta las comedias de los 90 con:

ref
  .orderBy('genre_year')
  .startAt('comedy_1990')
  .endAt('comedy_2000')
  .on('child_added', function(snapshot) { 
      var movie = snapshot.val();
      console.log(movie);
  });

Si necesita filtrar más allá del año, asegúrese de agregar las otras partes de fecha en orden descendente, por ejemplo "comedy_1997-12-25". De esta manera, el orden lexicográfico que Firebase hace en los valores de cadena será el mismo que el orden cronológico.

Esta combinación de valores en una propiedad puede funcionar con más de dos valores, pero solo puede hacer un filtro de rango en el último valor de la propiedad compuesta.

Una variante muy especial de esto es implementada por la biblioteca GeoFire para Firebase . Esta biblioteca combina la latitud y la longitud de una ubicación en un llamado Geohash , que luego se puede usar para realizar consultas de rango en tiempo real en Firebase.

3. crear un índice personalizado mediante programación

Otra alternativa es hacer lo que todos hemos hecho antes de agregar esta nueva API de consulta: crear un índice en un nodo diferente:

  "movies"
      // the same structure you have today
  "by_genre"
      "comedy"
          "by_lead"
              "Jack Nicholson"
                  "movie1"
              "Jim Carrey"
                  "movie3"
      "Horror"
          "by_lead"
              "Jack Nicholson"
                  "movie2"

Probablemente hay más enfoques. Por ejemplo, esta respuesta destaca un índice personalizado alternativo en forma de árbol: https://stackoverflow.com/a/34105063

He escrito una biblioteca personal que le permite ordenar por múltiples valores, con todos los pedidos realizados en el servidor.

¡Conoce Querybase!

Querybase incluye una referencia de base de datos de Firebase y una matriz de campos en los que desea indexar. Cuando cree nuevos registros, manejará automáticamente la generación de claves que permiten múltiples consultas. La advertencia es que solo admite equivalencia directa (no menor o mayor que).

const databaseRef = firebase.database().ref().child('people');
const querybaseRef = querybase.ref(databaseRef, ['name', 'age', 'location']);

// Automatically handles composite keys
querybaseRef.push({ 
  name: 'David',
  age: 27,
  location: 'SF'
});

// Find records by multiple fields
// returns a Firebase Database ref
const queriedDbRef = querybaseRef
 .where({
   name: 'David',
   age: 27
 });

// Listen for realtime updates
queriedDbRef.on('value', snap => console.log(snap));

var ref = new Firebase('https://your.firebaseio.com/');

Query query = ref.orderByChild('genre').equalTo('comedy');
query.addValueEventListener(new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot dataSnapshot) {
        for (DataSnapshot movieSnapshot : dataSnapshot.getChildren()) {
            Movie movie = dataSnapshot.getValue(Movie.class);
            if (movie.getLead().equals('Jack Nicholson')) {
                console.log(movieSnapshot.getKey());
            }
        }
    }

    @Override
    public void onCancelled(FirebaseError firebaseError) {

    }
});

La respuesta de Frank es buena, pero Firestore presentó array-containsrecientemente eso hace que sea más fácil hacer Y consultas.

Puede crear un filterscampo para agregarle filtros. Puede agregar tantos valores como necesite. Por ejemplo, para filtrar por comedia y Jack Nicholson , puede agregar el valor, comedy_Jack Nicholsonpero si también lo desea por comedia y 2014 , puede agregar el valor comedy_2014sin crear más campos.

{
"movies": {
    "movie1": {
        "genre": "comedy",
        "name": "As good as it gets",
        "lead": "Jack Nicholson",
        "year": 2014,
        "filters": [
          "comedy_Jack Nicholson",
          "comedy_2014"
        ]
    }
  }  
}

Firebase no permite realizar consultas con múltiples condiciones. Sin embargo, encontré una forma de evitar esto:

Necesitamos descargar los datos filtrados iniciales de la base de datos y almacenarlos en una lista de matriz.

                Query query = databaseReference.orderByChild("genre").equalTo("comedy");
                databaseReference.addValueEventListener(new ValueEventListener() {
                    @Override
                    public void onDataChange(@NonNull DataSnapshot dataSnapshot) {

                        ArrayList<Movie> movies = new ArrayList<>();
                        for (DataSnapshot dataSnapshot1 : dataSnapshot.getChildren()) {
                            String lead = dataSnapshot1.child("lead").getValue(String.class);
                            String genre = dataSnapshot1.child("genre").getValue(String.class);

                            movie = new Movie(lead, genre);

                            movies.add(movie);

                        }

                        filterResults(movies, "Jack Nicholson");

                        }

                    }

                    @Override
                    public void onCancelled(@NonNull DatabaseError databaseError) {

                    }
                });

Una vez que obtengamos los datos filtrados iniciales de la base de datos, necesitamos hacer más filtros en nuestro backend.

public void filterResults(final List<Movie> list,  final String genre) {
        List<Movie> movies = new ArrayList<>();
        movies = list.stream().filter(o -> o.getLead().equals(genre)).collect(Collectors.toList());
        System.out.println(movies);

        employees.forEach(movie -> System.out.println(movie.getFirstName()));
    }

ref.orderByChild("lead").startAt("Jack Nicholson").endAt("Jack Nicholson").listner....

Esto funcionará