Operaciones CRUD en Firebase con MQL

Introducción

Si alguna vez has intentado crear una aplicación móvil o web, sabrás que gestionar el backend puede ser una de las partes más complejas y que más tiempo consume del desarrollo. Ahí es donde Firebase, la popular plataforma de «backend como servicio» (BaaS) de Google, destaca de verdad. Elimina gran parte del trabajo pesado que implican las tareas de backend, lo que permite a los desarrolladores centrarse más en crear funcionalidades y menos en gestionar la infraestructura.

Firebase ofrece una amplia gama de herramientas para el desarrollo de aplicaciones (autenticación, funciones en la nube, análisis, alojamiento, informes de errores y más), pero una de sus características más potentes y utilizadas son sus soluciones de bases de datos. Firebase ofrece dos bases de datos NoSQL principales: Firebase Realtime Database y Cloud Firestore. Si bien cumplen funciones similares, cada una tiene sus propias ventajas, y la elección entre ellas depende en gran medida de las necesidades específicas de su proyecto.

Firebase Realtime Database

La base de datos en tiempo real de Firebase existe desde los inicios de Firebase y es especialmente adecuada para aplicaciones donde la baja latencia y la sincronización instantánea de datos entre clientes son cruciales. Esto la hace ideal para casos como chats, juegos multijugador, paneles de control en tiempo real o cualquier otra aplicación donde los usuarios necesiten ver actualizaciones en tiempo real sin necesidad de actualizar la pantalla.

La base de datos en tiempo real utiliza un árbol JSON simple y plano para almacenar los datos. Su sencillez hace que sea fácil empezar a usarla y que pueda ofrecer actualizaciones ultrarrápidas, incluso en conexiones lentas. Sin embargo, debido a su estructura plana, las cosas pueden volverse un poco difíciles de manejar a medida que sus datos se vuelven más complejos. Los datos anidados, las relaciones profundas y las consultas filtradas pueden requerir una planificación más cuidadosa en comparación con una base de datos tradicional.

Cloud Firestore

Cloud Firestore, a menudo llamado simplemente Firestore, es la más reciente de las dos bases de datos que ofrece Firebase. Fue diseñado teniendo en cuenta la escalabilidad, la estructura y las consultas avanzadas. Firestore admite un modelo de datos más jerárquico y basado en documentos. Organiza los datos en colecciones y documentos, lo que ofrece a los desarrolladores una forma más estructurada y escalable de gestionar relaciones complejas entre datos.

Firestore también incluye potentes funciones como:

• Consultas avanzada: filtrar por varios campos, ordenar resultados y paginar consultas.
• Persistencia sin conexión: sincronización automática de los datos en cuanto el dispositivo se vuelva a conectar.
• Marcas de tiempo del servidor y operaciones atómicas.
• Reglas de seguridad más detalladas
• Mejor integración con otros servicios de Google Cloud

En general, si tu aplicación es relativamente pequeña y prioriza la velocidad y la simplicidad, Realtime Database puede ser una mejor opción. Si estás desarrollando algo más ambicioso que requiera un modelado de datos complejo y soporte a gran escala, Firestore es probablemente la mejor opción.

Configuración de un proyecto y una base de datos de Firebase (paso a paso)

Ahora que ya tienes una mejor idea de qué son las bases de datos de Firebase y en qué se diferencian, vamos a ver cómo configurar una desde cero. Explicaremos cómo crear un proyecto de Firebase, elegir la base de datos y configurar ajustes básicos como las reglas de seguridad y la estructura de datos.

Paso 1: Crear un proyecto de Firebase
Para empezar a usar Firebase, necesitarás una cuenta de Google. Dirígete a la consola de Firebase y haz clic en el botón "Agregar proyecto". Se le pedirá que proporcione un nombre para el proyecto (puede ser cualquiera) y tendrá la opción de habilitar Google Analytics para su proyecto. Puedes omitir esto por ahora, o habilitarlo si deseas realizar un seguimiento del comportamiento del usuario más adelante.

Una vez que haga clic en "Crear proyecto", Firebase se encargará del aprovisionamiento en segundo plano. En pocos segundos, tu proyecto estará listo.

Paso 2: Añade tu aplicación a Firebase
Antes de poder utilizar las funciones de Firebase, debes registrar tu aplicación, ya sea una aplicación web, Android o iOS. Haz clic en el icono de la plataforma correspondiente (por ejemplo, el símbolo web "/") y sigue los pasos para registrar tu aplicación. En el caso de una aplicación web, se te proporcionará un fragmento de código de configuración (las credenciales de tu proyecto de Firebase) que deberás copiar en tu código.

Así es como podría verse el fragmento de configuración:

const firebaseConfig = {
  apiKey: "YOUR_API_KEY",
  authDomain: "your-app.firebaseapp.com",
  projectId: "your-app",
  storageBucket: "your-app.appspot.com",
  messagingSenderId: "SENDER_ID",
  appId: "APP_ID"
};

Utiliza esta configuración para inicializar Firebase en tu aplicación.

Paso 3: Activa tu base de datos preferida
Una vez que hayas configurado tu proyecto y tu aplicación, es el momento de elegir una base de datos. En la consola de Firebase, busca la sección «Build» en el menú de navegación de la izquierda y selecciona Realtime Database o Cloud Firestore, según cuál quieras utilizar.

Haz clic en «Crear base de datos» y elige la ubicación para tus datos. En la mayoría de las aplicaciones, la ubicación predeterminada debería ser suficiente, pero quizá te interese seleccionar una región más cercana a tu base de usuarios para obtener un mejor rendimiento.

Paso 4: Configurar las reglas de seguridad
Las bases de datos de Firebase son increíblemente flexibles, pero esa flexibilidad conlleva una responsabilidad. Por defecto, Firebase restringe el acceso a tu base de datos por motivos de seguridad. Durante la configuración, se le pedirá que seleccione un modo de reglas de seguridad. Para el desarrollo o las pruebas, puede utilizar temporalmente el "modo de prueba", que hace que tu base de datos sea pública para lectura y escritura. ¡Asegúrate de no usar esto en producción!

Así es como se ve el modo de prueba:

{
  "rules": {
    ".read": "true",
    ".write": "true"
  }
}

Para entornos de producción, conviene escribir reglas más específicas que controlen quién puede leer o escribir qué partes de los datos. Las reglas de seguridad de Firebase pueden basarse en la autenticación del usuario, los campos del documento, los parámetros de la solicitud y mucho más.

• URL de la base de datos y clave API: Para autenticar las solicitudes, necesitarás la clave API y la URL de la base de datos de tu proyecto de Firebase. Estas opciones se encuentran en la configuración de tu proyecto, en “Clave de API web” y “URL de la base de datos en tiempo real” (o en el punto final REST de Firestore).

• Comprensión de los puntos finales REST: Las bases de datos de Firebase son accesibles a través de las API REST. Por ejemplo:

  • Realtime Database: https://PROJECT_ID.firebaseio.com/path/to/data.json

  • Firestore: https://firestore.googleapis.com/v1/projects/PROJECT_ID/databases/(default)/documents/path/to/document

Para demostrar cómo funcionan las operaciones de lectura y escritura, comenzaremos creando una nueva colección —es decir, una estructura lógica para organizar documentos— y la rellenaremos manualmente con ejemplos de entradas de usuario. Esta configuración servirá de base para practicar la recuperación de datos en pasos posteriores, lo que le permitirá comprender de forma clara y completa el flujo de trabajo de Firestore. 

Crea tu primera colección

Haz clic en el botón Iniciar colección. Aparecerá una ventana modal que le pedirá que nombre su colección. Llamémosla users, ya que vamos a simular una pequeña base de datos de usuarios.

Tras nombrar la colección, se le pedirá que cree el primer documento dentro de ella. Firestore genera automáticamente un identificador de documento aleatorio si no quieres configurarlo manualmente, pero para mayor claridad, crea uno tú mismo; utilicemos algo sencillo como usuarios.

Añadir campos a tu documento
Una vez que le hayas dado un ID a tu documento, es hora de completarlo con algunos campos. Piensa en estos campos como si fueran columnas de una base de datos tradicional, pero con mucha más flexibilidad.

Podrías empezar con algo como esto:

• Nombre → "Jane Doe"

Como nuestro objetivo es añadir los datos automáticamente con código MQL5, este paso no es especialmente importante. Ahora, conectémonos a la base de datos.

Conexión a la base de datos
El punto final REST para nuestra base de datos «my-users-mql5» sería:

 https://firestore.googleapis.com/v1/projects/my-users-mql5/databases/(default)/documents/users/

Si pegas ahora esa URL en un navegador, lo más probable es que veas lo siguiente:

Ahora que ya tienes configurada tu colección usuarios, estás en las mejores condiciones para empezar a aprender a leer datos de Firestore mediante código. En los siguientes pasos, veremos cómo agregar datos, obtener documentos, escuchar actualizaciones en tiempo real y usar consultas para filtrar y ordenar los datos.

Creación de datos

El método HTTP POST está diseñado para enviar datos a un recurso específico; en otras palabras, para enviar datos a un servidor. Cuando realizas una solicitud POST, normalmente incluyes datos en el cuerpo de la solicitud, que el servidor procesa para crear un nuevo recurso (por ejemplo, una nueva cuenta de usuario, una nueva entrada de blog o una nueva entrada en tu base de datos).

Esto difiere de una solicitud GET, que se utiliza únicamente para recuperar datos y nunca debe modificar nada en el servidor. POST, por el contrario, se centra en enviar y modificar: crea algo nuevo.

En cada caso, el cliente envía datos estructurados (normalmente en formato JSON) al backend o directamente a una función sin servidor, que a continuación almacena esos datos en algún lugar —a menudo en una base de datos como Firestore—.

void add_data()
  {
   string url = "https://firestore.googleapis.com/v1/projects/my-users-mql5/databases/(default)/documents/users";
   string jsonData = "{\"fields\":{\"Name\":{\"stringValue\":\"Jane Doe\"}}}";
   uchar postData[], result[];
   StringToCharArray(jsonData, postData, 0, StringLen(jsonData), CP_UTF8);
   string header;
   int res = WebRequest("POST", url, "Content-Type: application/json\r\n", 5000, postData, result, header);
   if(res == 200)
     {
      Print("Success: ", CharArrayToString(result));
     }
   else
     {
      Print("Error ", res, ": ", CharArrayToString(result));
     }
  }

Utilizando el código anterior, hemos añadido una nueva entrada llamada "Jane Doe" con un ID único generado por Firebase, lo que garantiza que no haya conflictos de claves incluso con la adición simultánea de datos. Podemos agregar tantas entradas de datos como sean necesarias, incluyendo campos anidados como correo electrónico, edad o marca de tiempo, estructurándolos como pares clave-valor dentro de la referencia de la base de datos. El siguiente paso es recuperar esos datos.

Lectura de datos

Ahora que nuestra base de datos está en pleno funcionamiento, es hora de empezar a interactuar con ella de forma significativa. Ya hemos creado y llenado una colección con algunos documentos de ejemplo, y hemos aprendido a enviar datos a Firestore utilizando el método POST. Es un buen comienzo, pero leer los datos es tan importante como escribirlos. De hecho, para muchas aplicaciones, la recuperación y visualización de datos es el núcleo de la experiencia del usuario.

Ya sea que estés cargando una lista de usuarios, mostrando un feed de noticias o generando un catálogo de productos, necesitarás una forma de obtener información de la base de datos. Y ahí es donde entra en juego el método GET.

El método GET es uno de los métodos básicos de solicitud HTTP. A diferencia de POST, que se utiliza para enviar datos y crear nuevos recursos, GET se utiliza pararecuperar información de un servidor. Se trata esencialmente de una operación de solo lectura: cuando envías una solicitud GET, le pides al servidor que devuelva algunos datos, pero no modificas nada en el lado del servidor.

Aquí va una analogía rápida: si una solicitud POST es como enviar un formulario para crear una nueva cuenta, una solicitud GET es como iniciar sesión y ver la información de tu perfil. No estás cambiando nada, simplemente estás recuperando datos que ya existen.

void authorize()
  {

// 1. Construct Firestore URL
   string url = "https://firestore.googleapis.com/v1/projects/my-users-mql5/databases/(default)/documents/users/";
// 2. Prepare headers
   string headers;
   headers += "Content-Type: application/json\r\n";
// 3. Send request
   char data[], result[];
   int timeout = 5000;
   int status = WebRequest("GET", url, headers, timeout, data, result, headers);
// 4. Handle response
   if(status == 200)
     {
      // Print("Firestore Data Received:");
      int filehandle = FileOpen("firebase-temp.txt", FILE_WRITE | FILE_BIN);
      if(filehandle != INVALID_HANDLE)
        {
         //--- Saving the contents of the result[] array to a file
         FileWriteArray(filehandle, result, 0, ArraySize(result));
         //--- Closing the file
         FileFlush(filehandle);
         FileClose(filehandle);
        }
      else
         Print("Error in FileOpen. Error code =", GetLastError());
     }
   else
     {
      Print("Error Code: ", status);
      Print("Response: ", CharArrayToString(result));
     }
  }

Y con solo unas pocas líneas de código, ya tenemos un archivo que contiene toda la información de la base de datos «firebase-temp.txt».

Permisos: Asegúrate de que las reglas de seguridad de Firestore permitan el acceso de lectura donde sea necesario. Para pruebas públicas, puedes usar reglas abiertas (por ejemplo, reglas abiertas como allow read: if true;), ¡pero para producción, sé más estricto!

Actualización de datos

Como probablemente ya habrás notado, cada vez que agregas un nuevo documento a tu base de datos de Firestore, ya sea manualmente a través de la consola o mediante programación utilizando el SDK de Firebase, se le asigna un ID de documento único. Este identificador puede parecer una cadena aleatoria de letras y números, como kJ73sd98ASQv, y a primera vista, puede que no parezca muy importante.

Firestore está estructurado en torno a colecciones y documentos. Una colección contiene varios documentos, y cada documento contiene datos en forma de pares clave-valor. Cuando añades un documento a una colección, puedes dejar que Firestore genere automáticamente un ID o puedes especificar uno manualmente.

Por ejemplo, cuando agregas un usuario a la colección de usuarios, podrías terminar con una ruta como esta:

usuarios/kJ73sd98ASQv

Esto significa que el documento de ese usuario está dentro de la colección y se identifica de forma única mediante el ID kJ73sd98ASQv. Si desea recuperar, actualizar o eliminar ese documento específico más adelante, deberá indicar la ruta completa, incluido el ID del documento.

Pero no se equivoquen: ese ID de documento es esencial. De hecho, es el identificador único que permite a Firestore (y, por extensión, a tu aplicación) localizar, modificar o eliminar de forma eficiente ese dato específico. Piénsalo como una huella dactilar: no hay dos documentos con el mismo ID, y ese identificador es lo que permite una interacción directa y precisa con cada documento individual.

Por lo tanto, a la hora de actualizar o eliminar datos en Firestore, conocer y utilizar el ID del documento es absolutamente fundamental.

A partir del ejemplo de "Jane Doe", nuestro punto final para el campo añadido es: 

https://firestore.googleapis.com/v1/projects/my-users-mql5/databases/(default)/documents/users/NoQ8m2vYLnGkykNhUjFE

Por lo tanto, nuestro ID de documento es:       

NoQ8m2vYLnGkykNhUjFE

Para actualizar estos datos, podemos utilizar el método "PATCH":

void update_entry(string doc_id)
  {
   string url = "https://firestore.googleapis.com/v1/projects/my-users-mql5/databases/(default)/documents/users/" + doc_id; //end point url
   string jsonData = "{\"fields\":{\"exampleField\":{\"stringValue\":\"Princess Doe\"}}}"; //specifiy data to be added
   uchar postData[], result[];
   StringToCharArray(jsonData, postData, 0, StringLen(jsonData), CP_UTF8); //convert plain string to char array to be sent to the db
   string header;
   int res = WebRequest("PATCH", url, "Content-Type: application/json\r\n", 5000, postData, result, header);
   if(res == 200)
     {
      Print("Success: ", CharArrayToString(result)); //if successful, print
     }
   else
     {
      Print("Error ", res, ": ", CharArrayToString(result)); //return error
     }
  }

Usando este código, actualizaremos el nombre de "Jane Doe" a "Princess Doe".

Eliminar las entradas

La última operación de esta serie sería eliminar la entrada. Para eliminar una entrada como "Jane Doe" de Firebase, puedes usar el método DELETE en la referencia específica de la base de datos que apunta al ID único de la entrada. Por ejemplo, al llamar a la función DELETE en el nodo hijo que contiene la clave autogenerada de Jane, se borrará permanentemente esa entrada de la base de datos. Esto se puede combinar con una cadena de promesas o una función de devolución de llamada para gestionar los estados de éxito/error, lo que garantiza una retroalimentación adecuada en su aplicación. Además, se deben configurar las reglas de seguridad de Firebase para restringir los permisos de eliminación, impidiendo que los usuarios no autorizados eliminen datos de forma involuntaria o maliciosa.

void delete_entry(string documentId)
  {
   string url = "https://firestore.googleapis.com/v1/projects/my-users-mql5" +
                "/databases/(default)/documents/users/" + documentId; //end point url with specified document ID
   uchar result[];
   uchar postData[]; // Empty payload for DELETE
   string headers = "Content-Type: application/json\r\n";
   string responseHeaders; // To store response headers (unused here)
// Correct WebRequest overload:
   int res = WebRequest(
                "DELETE",       // HTTP method
                url,            // Full URL with document ID
                headers,        // Request headers
                5000,           // Timeout (5 seconds)
                postData,       // Empty payload (uchar array, not NULL)
                result,         // Response data
                responseHeaders // Response headers (ignored)
             );
   if(res == 200)
     {
      Print("Document deleted"); //sucess
     }
   else
     {
      Print("Error ", res, ": ", CharArrayToString(result));
     }
  }

Al especificar el ID del documento, la entrada se eliminaría. 

Uso de Firebase en el trading algorítmico

Ahora que hemos aprendido la aplicación de funciones CRUD sencillas en MQL, podemos utilizar un ejemplo práctico de cómo aplicar este conocimiento en el trading algorítmico. En este ejemplo, enviaremos información de trading desde la terminal a Firebase y y luego leeremos la señal en un panel.

Envío de información de trading a Firebase
Podemos utilizar código MQL5 básico para obtener información de las posiciones cerradas y estos datos se enviarán a la base de datos para su procesamiento. 

datetime last_closed_time;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   last_closed_time = TimeCurrent();
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void add_data(ulong ticket, string symbol, double lot, double profit)
  {
   string url = "https://firestore.googleapis.com/v1/projects/my-users-mql5/databases/(default)/documents/users";
// Build JSON dynamically using function parameters
   string trade_id = "Trade_" + IntegerToString((int)ticket);
   string jsonData =
      "{"
      "\"fields\":{"
      "\"" + trade_id + "\":{"
      "\"mapValue\":{"
      "\"fields\":{"
      "\"symbol\":{\"stringValue\":\"" + symbol + "\"},"
      "\"lot\":{\"doubleValue\":" + DoubleToString(lot, 2) + "},"
      "\"profit\":{\"doubleValue\":" + DoubleToString(profit, 2) + "}"
      "}"
      "}"
      "}"
      "}"
      "}";
   uchar postData[], result[];
   StringToCharArray(jsonData, postData, 0, StringLen(jsonData), CP_UTF8);
   string header;
   int res = WebRequest("POST", url, "Content-Type: application/json\r\n", 5000, postData, result, header);
   if(res == 200)
     {
      Print("Success: ", CharArrayToString(result));
     }
   else
     {
      Print("Error ", res, ": ", CharArrayToString(result));
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnTrade()
  {
   HistorySelect(0, TimeCurrent());
   for(int i = 0; i < HistoryDealsTotal(); i++)
     {
      if(deal.SelectByIndex(i))
        {
         if(deal.Time() >= last_closed_time && last_closed_time != 0)
           {
            if(deal.Entry() == DEAL_ENTRY_OUT)
              {
               add_data(deal.Ticket(), deal.Symbol(), deal.Volume(), deal.Profit());
              }
           }
        }
     }
   last_closed_time = TimeCurrent();
  }

Sincronización de una cartera desde MQL5 a Firestore
Cada dato que se envía puede almacenarse, descargarse e incluso leerse línea por línea antes de mostrarse en un panel de control. Esto permite revisar el historial de operaciones de forma clara y organizada, en lugar de tener que desplazarse por registros interminables o recurrir a capturas de pantalla. Al estructurar los datos de esta manera, los operadores pueden visualizar su rendimiento de forma más eficaz e identificar patrones que, de otro modo, podrían pasar desapercibidos.

int OnInit()
  {
//---
   draw_dashboard();
   get_data();
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void draw_dashboard()
  {
   ObjectCreate(0, "dash-board", OBJ_RECTANGLE_LABEL, 0, 0, 0);
   ObjectSetInteger(0, "dash-board", OBJPROP_XDISTANCE, 20);
   ObjectSetInteger(0, "dash-board", OBJPROP_YDISTANCE, 20);
   ObjectSetInteger(0, "dash-board", OBJPROP_XSIZE, 250);
   ObjectSetInteger(0, "dash-board", OBJPROP_YSIZE, 150);
   ObjectSetInteger(0, "dash-board", OBJPROP_BGCOLOR, clrDarkSlateGray);
   ObjectCreate(0, "dash-tv", OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, "dash-tv", OBJPROP_XDISTANCE, 50);
   ObjectSetInteger(0, "dash-tv", OBJPROP_YDISTANCE, 40);
   ObjectSetString(0, "dash-tv", OBJPROP_TEXT, "Total Volume: " +  DoubleToString(trading_volume_from_file(), 2));
   ObjectSetInteger(0, "dash-tv", OBJPROP_COLOR, clrWhite);
   ObjectCreate(0, "dash-profit", OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, "dash-profit", OBJPROP_XDISTANCE, 50);
   ObjectSetInteger(0, "dash-profit", OBJPROP_YDISTANCE, 80);
   ObjectSetString(0, "dash-profit", OBJPROP_TEXT, "Total Profit: " + DoubleToString(pnl_from_file(), 2));
   ObjectSetInteger(0, "dash-profit", OBJPROP_COLOR, clrWhite);
  }
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| Get total trading volume                                         |
//+------------------------------------------------------------------+
double trading_volume_from_file(string filename = "firebase-temp-trade.txt")
  {
   double tv = 0;
   int filehandle = FileOpen(filename, FILE_READ | FILE_TXT | FILE_ANSI);
   if(filehandle == INVALID_HANDLE)
     {
      Print("Error opening file: ", GetLastError());
      return 0;
     }
   string line;
   while(!FileIsEnding(filehandle))
     {
      line = FileReadString(filehandle);
      // Look for lot values
      if(StringFind(line, "lot") != -1)
        {
         string raw0 = FileReadString(filehandle);
         int stat_int = StringFind(raw0, "d", 0);
         string raw = StringSubstr(raw0, stat_int + 14, -1);
         double profit = StringToDouble(raw);
         //---
         tv += NormalizeDouble(profit, 2);
        }
     }
   FileClose(filehandle);
   return tv;
  }

//+------------------------------------------------------------------+
//| Get total PnL                                                    |
//+------------------------------------------------------------------+
double pnl_from_file(string filename = "firebase-temp-trade.txt")
  {
   double p_l = 0;
   int filehandle = FileOpen(filename, FILE_READ | FILE_TXT | FILE_ANSI);
   if(filehandle == INVALID_HANDLE)
     {
      Print("Error opening file: ", GetLastError());
      return 0;
     }
   int line_no = 0;
   while(!FileIsEnding(filehandle))
     {
      string line = FileReadString(filehandle);
      line_no++;
      // Look for profit values
      if(StringFind(line, "profit") != -1)
        {
         string raw0 = FileReadString(filehandle);
         int stat_int = StringFind(raw0, "d", 0);
         string raw = StringSubstr(raw0, stat_int + 14, -1);
         double profit = StringToDouble(raw);
         //---
         p_l += profit;
        }
     }
   FileClose(filehandle);
   return p_l;
  }

//+------------------------------------------------------------------+
void get_data()
  {
// 1. Construct Firestore URL
   string url = "https://firestore.googleapis.com/v1/projects/my-users-mql5/databases/(default)/documents/users";
// 2. Prepare headers
   string headers;
   headers += "Content-Type: application/json\r\n";
// 3. Send request
   char data[], result[];
   int timeout = 5000;
   int status = WebRequest("GET", url, headers, timeout, data, result, headers);
// 4. Handle response
   if(status == 200)
     {
      // Print("Firestore Data Received:");
      int filehandle = FileOpen("firebase-temp-trade.txt", FILE_WRITE | FILE_BIN);
      if(filehandle != INVALID_HANDLE)
        {
         //--- Saving the contents of the result[] array to a file
         FileWriteArray(filehandle, result, 0, ArraySize(result));
         //--- Closing the file
         FileFlush(filehandle);
         FileClose(filehandle);
        }
      else
         Print("Error in FileOpen. Error code =", GetLastError());
     }
   else
     {
      Print("Error Code: ", status);
      Print("Response: ", CharArrayToString(result));
     }
  }
//+------------------------------------------------------------------+

El resultado es el siguiente:

Conclusión

Las bases de datos son la columna vertebral de las aplicaciones modernas, y dominarlas es una competencia imprescindible para los desarrolladores. Al aprender a interactuar con Firebase, ya sea mediante la sincronización instantánea de Realtime Database o las potentes consultas de Firestore, has adquirido un conjunto de herramientas fundamentales para crear aplicaciones dinámicas y basadas en datos. 

Nombre del archivo	Descripción
firebase-users.mq5	Archivo que contiene el código para realizar funciones CRUD con Firestore.
Download_Infor.mq5	Archivo que contiene el código para descargar información de Firestore y mostrarla en el gráfico.
Sending_Trading_Info.mq5	Archivo que contiene el código para enviar información de operaciones a Firestore.