Bienvenida e Introducción

1

Firebase para Web: Autenticación y Base de Datos

2

Firebase: Plataforma Integral para Desarrollar Aplicaciones Web y Móviles

3

Creación y gestión de un videoblog con Firebase

Consola Web de Administración

4

Configuración de Firebase en Proyectos Web y Móviles

5

Configuración de Firebase en Proyecto Web con JavaScript

Autenticación de Usuarios

6

Autenticación y Creación de Usuarios con Firebase

7

Autenticación con Firebase: Email y Google paso a paso

8

Autenticación de Usuarios con Firebase: Registro y Verificación de Email

9

Autenticación con Google usando Firebase en aplicaciones web

10

Implementación de Autenticación con Facebook en Firebase

11

Gestión de Autenticación de Usuarios con Firebase

12

Gestión de Usuarios en Firebase: Creación, Inhabilitación y Plantillas

13

Exportar e Importar Usuarios en Firebase Auth

Gestión de la Base de Datos

14

Firestore: Gestión y Estructura de Datos en Firebase

15

Comparación entre Realtime Database y Firestore de Firebase

16

Configuración de Firestore en un Proyecto Firebase

17

Inserción de documentos en Firestore con JavaScript

18

Consultas en Tiempo Real con Firestore para Aplicaciones Web

19

Consultas y Operaciones de Datos en Firestore

20

Reglas de Seguridad en Bases de Datos con Firestore

21

Creación y gestión de índices en Firestore para optimizar consultas

Almacenamiento de archivos

22

Almacenamiento de Archivos en Firebase: Gestión y Seguridad

23

Subir Imágenes a Firebase Storage desde un Blog

24

Reglas de Seguridad en Firebase Storage para Blogs

Hosting

25

Características y beneficios del hosting de Firebase

26

Despliegue de Aplicaciones con Firebase Hosting

27

Configuración Personalizada de Hosting con Firebase

Notificaciones Push

28

Notificaciones Push con Firebase Cloud Messaging

29

Implementación de Notificaciones en Blog con Firebase

30

Implementación de Notificaciones Push con Firebase y Firestore

31

Implementación de Notificaciones Push con Firebase en Blogs

Conclusiones

32

Integración de Firebase en Aplicaciones Web

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Firebase 5 para Web

Curso de Firebase 5 para Web

Juan Guillermo Gómez Torres

Juan Guillermo Gómez Torres

Consultas y Operaciones de Datos en Firestore

19/32
Recursos

¿Qué capacidades avanzadas ofrece Firestore para consultas e inserciones de datos?

Firestore, la base de datos no relacional de Google Cloud, proporciona una serie de potentes herramientas para manejar datos de forma eficiente. En este artículo, exploraremos diversas capacidades de Firestore en la consulta e inserción de datos, desde operaciones básicas hasta técnicas avanzadas como las operaciones batch y el manejo de datos con índices.

¿Cómo se realiza una inserción con un identificador propio?

Una de las funcionalidades útiles de Firestore es la inserción de documentos con un identificador proporcionado por el usuario. Aunque Firestore puede generar automáticamente un ID único, a veces puede ser necesario asignar un identificador propio. Para ello, se utiliza una función que permite definir el ID del documento al momento de la inserción.

const postRef = firestore.collection('posts').doc('customID');
postRef.set({
  title: 'Custom Post',
  content: 'This is a custom ID post'
});

¿Qué son las operaciones batch y cómo se ejecutan?

Las operaciones batch permiten ejecutar múltiples operaciones simultáneamente. Son ideales para mejorar el rendimiento de la aplicación al reducir latencia en la comunicación con Firestore.

  • Declarar operaciones batch: Se asigna una referencia para ejecutar las operaciones.
  • Adjuntar las operaciones: Utilizar batch.set para insertar documentos.
  • Confirmar las operaciones: Con batch.commit se ejecutan todas las operaciones.
const batch = firestore.batch();
const post1Ref = firestore.collection('posts').doc('post1');
const post2Ref = firestore.collection('posts').doc('post2');
const post3Ref = firestore.collection('posts').doc('post3');

batch.set(post1Ref, { title: 'Batch Post 1' });
batch.set(post2Ref, { title: 'Batch Post 2' });
batch.set(post3Ref, { title: 'Batch Post 3' });

batch.commit().then(() => {
  console.log('Batch executed successfully.');
});

¿Cómo se añade un nuevo campo a un documento sin reemplazar los existentes?

Para actualizar un documento añadiendo un nuevo campo sin perder los existentes, Firestore ofrece la opción de fusionar los campos utilizando el atributo merge.

const postRef = firestore.collection('posts').doc('postID');
postRef.set({ imageLink: 'http://example.com/image.png' }, { merge: true });

¿Cómo se realizan actualizaciones de documentos?

Firestore permite actualizar campos de un documento específico mediante la función update. Esto involucra referenciar el documento y proporcionar un objeto con los campos a actualizar.

const postRef = firestore.collection('posts').doc('postID');
postRef.update({ title: 'Updated Title' });

¿Qué opciones existen para realizar consultas en Firestore?

Firestore soporta una variedad de consultas directas y compuestas que permiten extraer datos siguiendo criterios específicos.

Consultas directas

Para obtener un documento específico, se utiliza .get() sobre la referencia del documento.

const docRef = firestore.collection('posts').doc('postID');
docRef.get().then(doc => {
  console.log(`Document Title: ${doc.data().title}`);
});

Consultas con filtros

Para buscar documentos que cumplan ciertos criterios, se puede usar filtros where.

firestore.collection('posts')
  .where('title', '==', 'Specific Title')
  .get()
  .then(snapshot => {
    snapshot.forEach(doc => {
      console.log(doc.id, '=>', doc.data());
    });
  });

Consultas compuestas

Firestore soporta consultas compuestas usando múltiples filtros con operadores como >=, <=, y ==.

firestore.collection('posts')
  .where('author', '==', 'AuthorName')
  .where('date', '<=', new Date())
  .get()
  .then(snapshot => {
    snapshot.forEach(doc => {
      console.log(doc.id, '=>', doc.data());
    });
  });

¿Cómo se gestionan los datos con consultas ordenadas y limitadas?

Firestore permite ordenar y limitar la cantidad de datos devueltos por una consulta mediante orderBy y limit.

firestore.collection('posts')
  .orderBy('title')
  .limit(3)
  .get()
  .then(snapshot => {
    snapshot.forEach(doc => {
      console.log(doc.id, '=>', doc.data());
    });
  });

¿Cómo eliminamos campos y documentos completos?

La eliminación de campos, así como de documentos completos, puede hacerse usando las funciones update para campos y delete para documentos.

Eliminar un campo específico

const postRef = firestore.collection('posts').doc('postID');
postRef.update({
  unwantedField: firebase.firestore.FieldValue.delete()
});

Eliminar un documento completo

firestore.collection('posts').doc('postID').delete().then(() => {
  console.log('Document successfully deleted!');
});

¡Estos son solo algunos de los métodos que Firestore ofrece para manejar datos de manera eficiente! A medida que te adentres en su uso, descubrirás que puedes optimizar aún más tus aplicaciones utilizando Firestore. Siempre es un buen momento para seguir aprendiendo y profundizando en estas tecnologías potentes.

Aportes 32

Preguntas 13

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Me encanto esta clase, he estado buscando un monton en internet en español, para realizar estas acciones en firestore y me ha costado encontrar algo. Excelente los ejemplos.

Este curso esta un poco desactualizado y si han estado viendo su consola, firebase lanza un error de que las cofiguraciones que aplicamos ya estan por defecto, como lo es

 const settings = { timestampsInSnapshots: true }
    this.db.settings(settings)

esto significa que ya no tenemos que poner estas lineas ya que ya estan por defecto

Como puedo hacer consultas con el operador OR?

¿Cuál es la diferencia entre realizar un .set() con merge y realizar un .update() ?

Ahora si se permite el != (diferente de…) como operador para consultas en firebase, y muchos más!!:

Fuente y documentación: https://firebase.google.com/docs/firestore/query-data/queries

Según he entendido, el batch sería algo así como hacer un Promise.all() en Javascript.

Metodos Avanzados de consulta en firebase

Pasos para poder realizar inserciones, consultas compuestas, límites y ordenamiento en esta clase deben:

Crear un nuevo proyecto(Folder), descargar los archivos (Archivos y Enlaces) y abrirlos en su editor

Copiar las credenciales index.html

<script>
        // Initialize Firebase
        var config = {
 
        };
        firebase.initializeApp(config);
    </script>
2.1. con las del proyecto de Firebase : Blogeek
// For Firebase JavaScript SDK v7.20.0 and later, measurementId is an optional field
var firebaseConfig = {
apiKey: “API_KEY”,
authDomain: “PROJECT_ID.firebaseapp.com”,
databaseURL: “https://PROJECT_ID.firebaseio.com”,
projectId: “PROJECT_ID”,
storageBucket: “PROJECT_ID.appspot.com”,
messagingSenderId: “SENDER_ID”,
appId: “APP_ID”,
measurementId: “G-MEASUREMENT_ID”,
};
  1. Iniciar el proyecto ya sea con Live Server de Visual Estudio Code

y no vi nada de paginación

Para poder trabajar en esta clase deben:

  1. descargar los archivos y abrirlos en su editor
  2. crear un projecto en Firestore,
  3. inicializar su firebase, copiando los Ids en el HTML
  4. Iniciar una base de datos en Firestore.
  5. ir a reglas y cambiar false por true en el if, ya con eso los deberia dejar seguir el tutorial

Me recuerda mucho al query builder de Eloquent en Laravel, obviamente tendrá sus diferencias…

Pero aquí me empiezo a preguntar… ¿Y la seguridad? Este código puede ser modificado del lado del cliente, así que nada le impide a mi usuario armar sus propias consultas y acceder a mi base de datos…

aqui falta algo.

Aqui hice un pequeno resumen usando codigo.

Agregar documentos con llaves propias

DB.collection("collection").doc(llave_personalizada)
	.set({...});

Actualizar datos en documentos

DB.collection("collection")
	.doc(id)
	.update({...});

Borrar atributo especifico dentro de documento

DB.collection("collection")
	.doc(id)
	.update({
		atributo: firebase.fitestore.FieldValue.delete()
	});

Consultar sin realtime

 DB.collection("collection")
	.doc(id)
	.ref.get().then((result) => {...})

Consultar por filtro where

DB.collection("collection")
	.where("atributo","operador",value)
	.get().then....

Nota: El “operador” puede ser ==, <,>, <= y >=. Para hacer un AND se ejecuta otro where a otro atributo con el operador y valor correspondiente. Firesotore no admite operaciones OR

Order by (asc o desc)

DB.collection("collection")
	.orderBy("atributo","asc")

limite de registros

DB.collection("collection")
	.limit(n)

Excelente

Excelente clase!, deberian hacer al menos una así para cada lenguaje o tecnología 👏

estas es una serie de videos donde se toma mas tiempo para desarrollar todo esto, mas despacio. Pueden verlo desde el segundo video

serie de videos de todas estas funciones pero mas despacio

se puede hacer paginado con las consultas?

Creo que esta es una forma un poco más clara que anidar tantas cosas

  const getAllDocuments = async () => {
    // .orderBy('price', 'asc') => Sort documents
    // by key 'price' in ascending 'asc'

    // .limit(2) => Limit the results (qty)

    // Example with order and limit
    // const allRef = await DB.collection('products').orderBy('price', 'asc').limit(3).get()

    const allRef = await DB.collection('products').get()
    const allDocs = allRef.docs.map(document => {
      return { id: document.id, ...document.data() }
    })

    if (allDocs.length) {
      setRealTimeData(allDocs)
      alert('Documentos traídos con éxito')
    }
  }```

Esos archivos a que nivel de projecto se deben de guardar?

Algo similar

con el batch podriamos hacer transacciones?

Muchas gracias profe!

buen día. como puedo probar estas consultas en la base de datos que cree en firestore?

Se puede interpretar a batch como una transaccion?

Realizando inserciones, consultas compuestas, límites y ordenamiento

Para el objeto firebase.firestore() tenemos los siguientes métodos:

const db = firebase.firestore()

// { ... } es un objeto con los campos/valor para el documento

// Para hacer referencia a una colección
const miColeccion = db.collection('nombre_coleccion')

// Para hacer referencia a un documento por su id de una colección
const miDoc = miColeccion.doc('id_doc')

// Para modificar un documento
miDoc.set({ ... })

// Para ejecutar varias tareas en una sola (ref# es una referencia a un documento)
const batch = db.batch()
const ref1 = db.collection('mi_colección').doc('id1') // ref al doc 1
batch.set(ref1, { ... }) // set al doc 1
const ref2 = db.collection('mi_colección').doc('id2') // ref al doc 2
batch.set(ref2, { ... }) // set al doc 2
const ref3 = db.collection('mi_colección').doc('id3') // ref al doc 3
batch.set(ref3, { ... }) // set al doc 3
...
batch.commit() // Ejecuta las tareas
	.then(() => ... )
	.catch(() => ... )

// Para añadir un nuevo documento
miColeccion.add({ ... })
	.then(() => ... )
	.catch(() => ... )

// Para añadir nuevos campos a un documento
miDoc.set(
	{ ... }, // Aquí es donde se escriben los nuevos campos con sus valores
	{ merge: true }
)

// Para actualizar campos de un documento
miDoc.update({ ... })

// Para actualizar un campo de objeto de un documento
miDoc.update({ 'nombre_objeto.campo_objeto': 'valor' })

// Para borrar un campo de un documento
miDoc.update({ 'nombre_campo': firebase.firestore.FieldValue.delete() })

// Para borrar un documento
miDoc.delete()

// Para obtener los campos de un documento (consultar un documento)
miDoc.get()
	.then(respDoc => {
		console.log(respDoc.data()) // Imprime los campos
		console.log(respDoc.data().nombre_campo) // Imprime el campo determinado
	}

// Para consultar con un filtro (WHERE)
miColeccion.where('titulo', '==', unTitulo).get() // consultando por titulo
	.then(querySnapshot => ...)
	// querySnapshot es un array con los documentos que cumplen el filtro

// Para buscar por varios filtros
miColeccion
	.where('campo1', ===, 'valor1')
	.where('campo2', ===, 'valor2')
	...
	.get().then(querySnapshot => ...)

// Para ordenar los documentos y obtener un numero limitado de ellos
miColeccion
	.orderBy('campo', 'asc') // Ordenando de forma ascendente
	.limit(n) // Solo 'n' documentos
	.get()
	.then(querySnapshot => ...)

Dejo una lectura sobre las consultas ya que no entendía si el metodo where() era de JS, JQuery o Firebase:

https://firebase.google.com/docs/firestore/query-data/queries?hl=es

Super!! esta clase es un buen compilado de todas las funciones que mas se utilizan. Toca guardar para tener de referencia mas adelante en nuestro proyecto. 😃

Excelente clase!

En esta clase practicamos las consultas para firestore(agregacion, edicion, consultas masivas, consultas unitarias, borrado, …):
Aquí el código para ahorrar tiempo: https://codesandbox.io/s/firebase-insercion-j8u4g?file=/firestore.js.
SOLO DEBEN AÑADIR(copiar/pegar) SU CONFIGURACION DE FIREBASE( la que esta en el proyecto > public > config > ConfigFirebase.js ), esto pegar en la variable varConfig en el script de abajo del *index.html del enlace que yo envié:

Para que el id se genere automáticamente solo dejamos vacío .doc()

    const ref2 = DB.collection('products').doc()
    batch.set(ref2, {
      name: 'Agregado desde Batch',
      image: 'Imagen',
      price: '123456',
      date: firebase.firestore.FieldValue.serverTimestamp(),
    })```

¿Cómo puedo hacer una subconsulta en firebase pero con angular? Gracias.

nota cuando se dice ‘al mismo tiempo’ no se refiere ‘en pararelo’… sino ‘secuencialmente’