CRUD Operations in Firebase Firestore with Flutter

13.3.2 CRUD Operations

In this section, we will delve into the core operations of interacting with Cloud Firestore in a Flutter application. CRUD operations—Create, Read, Update, and Delete—are fundamental to managing data in any application. We’ll explore how to implement these operations using the cloud_firestore plugin, ensuring you have a solid foundation for integrating Firebase into your Flutter projects.

Setting Up cloud_firestore Plugin

Before we can perform any operations with Firestore, we need to set up the cloud_firestore plugin in our Flutter project. This involves adding the plugin as a dependency and configuring it properly.

Adding the Dependency

To begin, add the cloud_firestore dependency to your pubspec.yaml file:

dependencies:
  flutter:
    sdk: flutter
  cloud_firestore: ^2.0.0

After adding the dependency, run the following command in your terminal to install it:

flutter pub get

This command fetches the necessary packages and prepares your project to use Firestore.

Creating Data (Add Documents)

Creating data in Firestore involves adding documents to a collection. Firestore allows you to either let it auto-generate a unique ID for each document or specify an ID yourself.

Adding a Document with Auto-generated ID

To add a document with an auto-generated ID, use the add method. This is useful when you don’t need to manage document IDs manually.

import 'package:cloud_firestore/cloud_firestore.dart';

CollectionReference users = FirebaseFirestore.instance.collection('users');

Future<void> addUser() {
  return users
      .add({
        'full_name': 'John Doe', // User's full name
        'age': 30,               // User's age
        'email': 'john.doe@example.com', // User's email
      })
      .then((value) => print('User Added'))
      .catchError((error) => print('Failed to add user: $error'));
}

Explanation:

• CollectionReference: Represents a reference to a collection in Firestore. Here, we reference the users collection.
• add Method: Adds a new document with an auto-generated ID.
• Error Handling: Uses catchError to handle any errors that occur during the operation.

Setting a Document with a Specific ID

If you need to manage document IDs, use the set method with a specific ID.

Future<void> setUser() {
  return users
      .doc('user_id') // Specify the document ID
      .set({
        'full_name': 'John Doe',
        'age': 30,
        'email': 'john.doe@example.com',
      })
      .then((value) => print('User Set'))
      .catchError((error) => print('Failed to set user: $error'));
}

Explanation:

• doc Method: Specifies the document ID. If the document doesn’t exist, it will be created.
• set Method: Sets the document data, overwriting any existing data.

Reading Data (Retrieve Documents)

Reading data from Firestore can be done by retrieving single documents or entire collections.

Get a Single Document

To retrieve a single document, use the get method on a document reference.

Future<void> getUser() async {
  DocumentSnapshot document = await users.doc('user_id').get();
  if (document.exists) {
    print('User Data: ${document.data()}');
  } else {
    print('No such document!');
  }
}

Explanation:

• DocumentSnapshot: Represents a snapshot of the document data.
• exists Property: Checks if the document exists in the collection.

Get Multiple Documents (Collection)

To retrieve all documents in a collection, use the get method on a collection reference.

Future<void> getUsers() async {
  QuerySnapshot querySnapshot = await users.get();
  final allData = querySnapshot.docs.map((doc) => doc.data()).toList();
  print('All Users: $allData');
}

Explanation:

• QuerySnapshot: Represents the result of a query, containing multiple documents.
• docs Property: Provides access to the documents in the query result.

Updating Data

Updating data in Firestore involves modifying specific fields of a document without overwriting the entire document.

Update Specific Fields

To update specific fields, use the update method.

Future<void> updateUser() {
  return users
      .doc('user_id')
      .update({'age': 31}) // Update the age field
      .then((value) => print('User Updated'))
      .catchError((error) => print('Failed to update user: $error'));
}

Explanation:

• update Method: Updates specified fields in the document. If the field doesn’t exist, it will be added.

Deleting Data

Deleting data in Firestore involves removing documents from a collection.

Delete a Document

To delete a document, use the delete method on a document reference.

Future<void> deleteUser() {
  return users
      .doc('user_id')
      .delete()
      .then((value) => print('User Deleted'))
      .catchError((error) => print('Failed to delete user: $error'));
}

Explanation:

• delete Method: Removes the document from the collection.

Best Practices and Considerations

When working with Firestore, consider the following best practices:

• Data Validation: Always validate data before adding or updating documents to ensure data integrity.
• Avoid Overwrites: Use the update method to modify specific fields instead of overwriting entire documents with set.
• Error Handling: Implement robust error handling to manage network issues and other potential errors.
• Security Rules: Configure Firestore security rules to protect your data from unauthorized access.

Practical Example: User Management System

Let’s consider a practical example of a user management system where you can add, read, update, and delete user profiles.

Adding a New User

Future<void> addNewUser(String fullName, int age, String email) {
  return users
      .add({
        'full_name': fullName,
        'age': age,
        'email': email,
      })
      .then((value) => print('User Added'))
      .catchError((error) => print('Failed to add user: $error'));
}

Retrieving All Users

Future<void> retrieveAllUsers() async {
  QuerySnapshot querySnapshot = await users.get();
  querySnapshot.docs.forEach((doc) {
    print('User: ${doc.data()}');
  });
}

Updating a User’s Email

Future<void> updateUserEmail(String userId, String newEmail) {
  return users
      .doc(userId)
      .update({'email': newEmail})
      .then((value) => print('User Email Updated'))
      .catchError((error) => print('Failed to update email: $error'));
}

Deleting a User

Future<void> removeUser(String userId) {
  return users
      .doc(userId)
      .delete()
      .then((value) => print('User Deleted'))
      .catchError((error) => print('Failed to delete user: $error'));
}

Conclusion

CRUD operations are the backbone of any data-driven application. By mastering these operations with Firestore in Flutter, you can build robust and scalable applications. Remember to follow best practices, such as data validation and error handling, to ensure your application is reliable and secure.

For further exploration, consider diving into Firestore’s advanced querying capabilities and real-time data synchronization features. These tools can significantly enhance your application’s functionality and user experience.

Quiz Time!