CRUD-Operationen in Firebase mit MQL

Einführung

Wenn Sie schon einmal versucht haben, eine mobile oder Web-App zu entwickeln, wissen Sie, dass die Verwaltung des Backends einer der komplexesten und zeitaufwändigsten Teile der Entwicklung sein kann. Das ist der Punkt, an dem Firebase, die beliebte Backend-as-a-Service (BaaS)-Plattform von Google, wirklich glänzt. Es nimmt den Entwicklern einen Großteil der schweren Arbeit ab, die mit Backend-Aufgaben verbunden ist, sodass sie sich mehr auf die Entwicklung von Funktionen und weniger auf die Verwaltung der Infrastruktur konzentrieren können.

Firebase bietet eine breite Palette von Tools zur Unterstützung der App-Entwicklung – Authentifizierung, Cloud-Funktionen, Analysen, Hosting, Absturzberichte und mehr – aber eine der leistungsstärksten und am häufigsten genutzten Funktionen sind die Datenbanklösungen. Firebase bietet zwei wichtige NoSQL-Datenbanken: Firebase Realtime Database und Cloud Firestore. Obwohl sie ähnlichen Zwecken dienen, haben sie jeweils einzigartige Stärken, und die Wahl zwischen ihnen hängt weitgehend von Ihren spezifischen Projektanforderungen ab.

Firebase-Echtzeit-Datenbank

Die Firebase Realtime Database gibt es schon seit den Anfängen von Firebase. Sie eignet sich besonders gut für Anwendungen, bei denen niedrige Latenzzeiten und eine sofortige Datensynchronisierung zwischen den Clients entscheidend sind. Das macht sie ideal für Anwendungen wie Chat-Apps, Multiplayer-Spiele, Live-Dashboards oder andere Anwendungen, bei denen die Nutzer Updates in Echtzeit sehen müssen, ohne den Bildschirm aktualisieren zu müssen.

Die Echtzeit-Datenbank verwendet einen einfachen, flachen JSON-Baum zum Speichern von Daten. Dank seiner Einfachheit ist es leicht zu bedienen und liefert blitzschnelle Aktualisierungen, selbst über langsamere Verbindungen. Aufgrund der flachen Struktur kann es jedoch etwas unhandlich werden, wenn Ihre Daten komplexer werden. Verschachtelte Daten, tiefe Beziehungen und gefilterte Abfragen können im Vergleich zu einer herkömmlichen Datenbank eine sorgfältigere Planung erfordern.

Cloud Firestore

Cloud Firestore, oft einfach Firestore genannt, ist das neuere der beiden Datenbankangebote von Firebase. Es wurde mit Blick auf Skalierbarkeit, Struktur und erweiterte Abfragen entwickelt. Firestore unterstützt ein eher hierarchisches, dokumentenbasiertes Datenmodell. Es organisiert Daten in Kollektionen und Dokumente und bietet Entwicklern eine besser strukturierte und skalierbare Möglichkeit, komplexe Datenbeziehungen zu verwalten.

Firestore verfügt außerdem über leistungsstarke Funktionen wie:

• Erweiterte Abfragen – nach mehreren Feldern filtern, Ergebnisse ordnen, Abfragen paginieren
• Offline-Persistenz – automatische Synchronisierung der Daten, sobald das Gerät wieder verbunden ist
• Serverseitige Zeitstempel und atomare Operationen
• Abstimmbare Sicherheitsregeln
• Bessere Integration mit anderen Google Cloud-Diensten

Wenn Ihre Anwendung relativ klein ist und Geschwindigkeit und Einfachheit im Vordergrund stehen, ist Realtime Database vielleicht die bessere Wahl. Wenn Sie etwas Ehrgeizigeres entwickeln, das eine komplexe Datenmodellierung und umfangreiche Unterstützung erfordert, ist Firestore wahrscheinlich die richtige Wahl.

Einrichten eines Firebase-Projekts und einer Datenbank (Schritt für Schritt)

Nun, da Sie eine bessere Vorstellung davon haben, was Firebase-Datenbanken sind und wie sie sich unterscheiden, gehen wir die Einrichtung einer Datenbank von Grund auf durch. Wir zeigen Ihnen, wie Sie ein Firebase-Projekt erstellen, Ihre Datenbank auswählen und grundlegende Einstellungen wie Sicherheitsregeln und Datenstruktur konfigurieren.

Schritt 1: Ein Firebase-Projekt erstellen
Um Firebase nutzen zu können, benötigen Sie ein Google-Konto. Rufen Sie die Firebase-Konsole auf und klicken Sie auf die Schaltfläche „Projekt hinzufügen“. Sie werden aufgefordert, einen Projektnamen anzugeben (dieser kann beliebig sein), und Sie haben die Möglichkeit, Google Analytics für Ihr Projekt zu aktivieren. Sie können diese Option vorerst auslassen oder sie aktivieren, wenn Sie das Nutzerverhalten später verfolgen möchten.

Sobald Sie auf „Create Project“ klicken, wird Firebase die Bereitstellung im Hintergrund übernehmen. Nach ein paar Sekunden ist Ihr Projekt fertig.

Schritt 2: Hinzufügen Ihrer App zu Firebase
Bevor Sie die Funktionen von Firebase nutzen können, müssen Sie Ihre App registrieren – egal, ob es sich um eine Web-App, Android oder iOS handelt. Klicken Sie auf das entsprechende Plattformsymbol (z. B. das Web-Symbol </>) und folgen Sie den Schritten zur Registrierung Ihrer App. Für eine Webanwendung erhalten Sie ein Konfigurations-Snippet (Ihre Firebase-Projekt-Anmeldedaten), das Sie in Ihren Code kopieren müssen.

So könnte das Config-Snippet aussehen:

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

Verwenden Sie diese Konfiguration, um Firebase in Ihrer Anwendung zu initialisieren.

Schritt 3: Aktivieren Sie Ihre bevorzugte Datenbank
Sobald Ihr Projekt und Ihre Anwendung eingerichtet sind, ist es an der Zeit, eine Datenbank zu wählen. Suchen Sie in der Firebase-Konsole in der linken Navigation den Abschnitt „Build“ und wählen Sie entweder Realtime Database oder Cloud Firestore aus, je nachdem, was Sie verwenden möchten.

Klicken Sie auf „Create Database“ und wählen Sie den Speicherort für Ihre Daten. Für die meisten Anwendungen sollte der Standardstandort ausreichen, aber vielleicht möchten Sie eine Region auswählen, die näher an Ihrer Nutzerbasis liegt, um die Leistung zu verbessern.

Schritt 4: Sicherheitsregeln konfigurieren
Firebase-Datenbanken sind unglaublich flexibel – aber mit dieser Flexibilität kommt auch Verantwortung. Standardmäßig schränkt Firebase den Zugriff auf Ihre Datenbank aus Sicherheitsgründen ein. Während der Einrichtung werden Sie aufgefordert, einen Sicherheitsregelmodus auszuwählen. Für Entwicklungs- oder Testzwecke können Sie vorübergehend den „Testmodus“ verwenden, in dem Ihre Datenbank öffentlich lesbar und beschreibbar ist. Achten Sie nur darauf, dass Sie dies nicht in der Produktion verwenden!

So sieht der Testmodus aus:

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

Für Produktionsumgebungen sollten Sie spezifischere Regeln aufstellen, die festlegen, wer welche Teile der Daten lesen oder schreiben darf. Firebase-Sicherheitsregeln können auf Nutzerauthentifizierung, Dokumentenfeldern, Anfrageparametern und mehr basieren.

• Datenbank-URL und API-Schlüssel: Zur Authentifizierung von Anfragen benötigen Sie den API-Schlüssel und die Datenbank-URL Ihres Firebase-Projekts. Diese finden Sie in Ihren Projekteinstellungen unter „Web-API-Schlüssel“ und „Echtzeit-Datenbank-URL“ (oder dem REST-Endpunkt von Firestore).

• Verstehen von REST-Endpunkten: Firebase-Datenbanken sind über REST-APIs zugänglich. Zum Beispiel:

  • Echtzeit-Datenbank: https://PROJECT_ID.firebaseio.com/path/to/data.json

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

Um zu demonstrieren, wie Lese- und Schreibvorgänge funktionieren, erstellen wir zunächst eine neue Kollektion – einen logischen Container zur Organisation von Dokumenten – und füllen sie manuell mit Beispielaufträgen. Diese Einrichtung dient als Grundlage für das Üben des Datenabrufs in späteren Schritten und vermittelt Ihnen ein klares, durchgängiges Verständnis des Firestore-Workflows. 

Erstellen Sie Ihre erste Kollektion

Klicken Sie auf die Schaltfläche Start Collection. Es wird ein modales Fenster angezeigt, in dem Sie aufgefordert werden, Ihre Kollektion zu benennen. Nennen wir sie „users“, da wir eine kleine Nutzerdatenbank simulieren wollen.

Nachdem Sie die Kollektion benannt haben, werden Sie aufgefordert, das erste Dokument darin zu erstellen. Firestore generiert automatisch eine zufällige Dokument-ID, wenn Sie diese nicht manuell festlegen möchten. Der Übersichtlichkeit halber sollten Sie jedoch selbst eine ID erstellen – nehmen wir etwas Einfaches wie users.

Felder zu Ihrem Dokument hinzufügen
Sobald Sie Ihrem Dokument eine ID gegeben haben, können Sie es mit einigen Feldern ausfüllen. Stellen Sie sich diese wie die Spalten in einer herkömmlichen Datenbank vor, aber mit viel mehr Flexibilität.

Sie könnten mit etwas beginnen wie:

• Name → „Jane Doe“

Da unser Ziel darin besteht, die Daten automatisch mit mql5-Code hinzuzufügen, ist der obige Teil nicht so wichtig. Verbinden wir uns nun mit der Datenbank.

Verbinden mit der Datenbank
Der REST-Endpunkt für unsere Datenbank „my-users-mql5“ wäre:

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

Wenn Sie diese URL jetzt in einen Browser einfügen, werden Sie wahrscheinlich sehen:

Nachdem Sie nun Ihre Kollektion users eingerichtet haben, können Sie lernen, wie man Daten aus Firestore mit Hilfe von Code liest. In den nächsten Schritten wird erläutert, wie man Daten hinzufügt, Dokumente abruft, auf Echtzeitaktualisierungen wartet und Abfragen zum Filtern und Sortieren der Daten verwendet.

Daten erstellen

Die HTTP-POST-Methode wurde entwickelt, um Daten an eine bestimmte Ressource zu übermitteln – mit anderen Worten, um Daten an einen Server zu senden. Bei einer POST-Anforderung geben Sie in der Regel Daten in den Text der Anforderung ein, die der Server dann verarbeitet, um eine neue Ressource zu erstellen (z. B. ein neues Nutzerkonto, einen neuen Blogbeitrag oder einen neuen Eintrag in Ihrer Datenbank).

Dies unterscheidet sich von einer GET-Anfrage, die nur zum Abrufen von Daten verwendet wird und nie etwas auf dem Server verändern sollte. Bei POST hingegen geht es um das Senden und Verändern – es entsteht etwas Neues.

In jedem Fall sendet der Client strukturierte Daten (normalerweise im JSON-Format) an das Backend oder direkt an eine serverlose Funktion, die diese Daten dann irgendwo speichert – häufig in einer Datenbank wie 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));
     }
  }

Mit dem obigen Code haben wir nun einen neuen Eintrag mit dem Namen „Jane Doe“ unter einer eindeutigen, von Firebase generierten ID hinzugefügt, um sicherzustellen, dass auch bei gleichzeitigen Datenergänzungen keine Schlüsselkonflikte auftreten. Wir können so viele Dateneinträge wie nötig hinzufügen, einschließlich verschachtelter Felder wie E-Mail, Alter oder Zeitstempel, indem wir sie als Schlüssel-Wert-Paare innerhalb der Datenbankreferenz strukturieren. Der nächste Schritt besteht darin, diese Daten abzurufen.

Daten lesen

Jetzt, da unsere Datenbank lebt, ist es an der Zeit, mit ihr sinnvoll zu interagieren. Wir haben bereits eine Kollektion mit einigen Beispieldokumenten erstellt und aufgefüllt und gelernt, wie man Daten mit der POST-Methode an Firestore sendet. Das ist ein guter Anfang, aber das Lesen von Daten ist genauso wichtig wie das Schreiben. Bei vielen Anwendungen ist das Abrufen und Anzeigen von Daten das Herzstück der Nutzererfahrung.

Egal, ob Sie eine Nutzerliste laden, einen Newsfeed anzeigen oder einen Produktkatalog rendern, Sie benötigen eine Möglichkeit, Informationen aus der Datenbank abzurufen. Und genau hier kommt die GET-Methode ins Spiel.

Die GET-Methode ist eine der wichtigsten HTTP-Anforderungsmethoden. Im Gegensatz zu POST, das zum Senden von Daten und zum Erstellen neuer Ressourcen verwendet wird, dient GET zum Abrufen von Informationen von einem Server. Dabei handelt es sich im Wesentlichen um einen reinen Lesevorgang: Wenn Sie eine GET-Anfrage senden, fordern Sie den Server auf, einige Daten zurückzugeben, aber Sie ändern nichts auf der Serverseite.

Hier eine kurze Analogie: Eine POST-Anfrage ist wie das Absenden eines Formulars zur Erstellung eines neuen Kontos, eine GET-Anfrage ist wie das Anmelden und Anzeigen Ihrer Profilinformationen. Sie ändern nichts, sondern rufen nur Daten ab, die bereits vorhanden sind.

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

Und mit nur wenigen Zeilen Code haben wir eine Datei, die alle Informationen aus der Datenbank „firebase-temp.txt “ enthält.

Erlaubt: Stellen Sie sicher, dass Ihre Firestore-Sicherheitsregeln bei Bedarf Lesezugriff erlauben. Für öffentliche Tests können Sie offene Regeln verwenden („allow read: if true;“), aber für einen Einsatz sollten Sie die Regeln verschärfen!

Daten aktualisieren

Wie Sie wahrscheinlich schon bemerkt haben, wird jedes Mal, wenn Sie ein neues Dokument zu Ihrer Firestore-Datenbank hinzufügen – sei es manuell über die Konsole oder programmatisch mit dem Firebase SDK – eine eindeutige Dokument-ID zugewiesen. Diese ID kann wie eine zufällige Folge von Buchstaben und Zahlen aussehen, z. B. kJ73sd98ASQv, und auf den ersten Blick scheint sie nicht sehr wichtig zu sein.

Firestore ist nach Kollektionen und Dokumenten strukturiert. Eine Kollektion enthält mehrere Dokumente, und jedes Dokument enthält Daten in Form von Schlüssel-Wert-Paaren. Wenn Sie ein Dokument zu einer Kollektion hinzufügen, können Sie entweder Firestore automatisch eine ID generieren lassen oder manuell eine ID angeben.

Wenn Sie z. B. einen Nutzer zur Nutzersammlung hinzufügen, können Sie einen Pfad wie diesen erhalten:

users/kJ73sd98ASQv

Das bedeutet, dass sich das Dokument für diesen Nutzer in der Nutzer-Kollektion befindet und durch die ID kJ73sd98ASQv eindeutig identifiziert wird. Wenn Sie das betreffende Dokument später abrufen, aktualisieren oder löschen möchten, müssen Sie auf den vollständigen Pfad verweisen, einschließlich der Dokumenten-ID.

Aber täuschen Sie sich nicht: Die Dokumenten-ID ist unerlässlich. Tatsächlich ist es der eindeutige Identifikator, der es Firestore (und damit auch Ihrer Anwendung) ermöglicht, diese spezifischen Daten effizient zu finden, zu ändern oder zu entfernen. Stellen Sie sich das wie einen Fingerabdruck vor – keine zwei Dokumente haben die gleiche ID, und diese ID ermöglicht eine direkte, präzise Interaktion mit jedem einzelnen Dokument.

Wenn es also darum geht, Daten in Firestore zu aktualisieren oder zu löschen, ist die Kenntnis und Verwendung der Dokument-ID absolut entscheidend.

Aus dem Beispiel „Jane Doe“ ergibt sich für das hinzugefügte Feld der Endpunkt: 

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

Unsere Dokumenten-ID lautet also:       

NoQ8m2vYLnGkykNhUjFE

Um diese Daten zu aktualisieren, können wir die Methode „PATCH“ verwenden:

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

Mit diesem Code wird der Name von „Jane Doe“ in „Princess Doe“ geändert.

Löschen von Einträgen

Die letzte Manipulation in dieser Reihe wäre die Löschung des Eintrags.  Um einen Eintrag wie „Jane Doe“ aus der Firebase Realtime Database zu löschen, können Sie die DELETE-Methode für den spezifischen Datenbankverweis verwenden, der auf die eindeutige ID des Eintrags verweist. Der Aufruf von DELETE für den untergeordneten Knoten, der den automatisch generierten Schlüssel von Jane enthält, löscht beispielsweise diesen Eintrag dauerhaft aus der Datenbank. Dies kann mit einer Versprechenskette oder einem Rückruf kombiniert werden, um Erfolgs-/Fehlerzustände zu behandeln und so ein angemessenes Feedback in Ihrer Anwendung zu gewährleisten. Zusätzlich sollten Firebase-Sicherheitsregeln so konfiguriert werden, dass Löschberechtigungen eingeschränkt werden, um zu verhindern, dass unbefugte Nutzer Daten unbeabsichtigt oder böswillig löschen.

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

Durch die Angabe der Dokument-ID würde der Eintrag gelöscht werden. 

Einsatz von Firebase im algorithmischen Handel

Nachdem wir nun die Anwendung einfacher CRUD-Funktionen in MQL kennengelernt haben, können wir anhand eines praktischen Beispiels zeigen, wie wir dieses Wissen im algorithmischen Handel anwenden. In diesem Beispiel werden wir Handelsinformationen vom Terminal an Firebase senden und dann das Signal auf einem Dashboard lesen

Senden von Handelsinformationen an firebase
Wir können einfachen MQL5-Code verwenden, um Informationen von geschlossenen Positionen zu erhalten, und diese Daten werden zur Verarbeitung an die Datenbank gesendet. 

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

Synchronisierung eines Portfolios von MQL5 zu Firestore
Alle gesendeten Daten können gespeichert, heruntergeladen und sogar Zeile für Zeile gelesen werden, bevor sie auf einem Dashboard angezeigt werden. Dies schafft eine klare und organisierte Möglichkeit, den Handelsverlauf zu überprüfen, anstatt durch endlose Protokolle zu scrollen oder sich auf Screenshots zu verlassen. Durch diese Strukturierung der Daten können die Händler ihre Leistung besser visualisieren und Muster erkennen, die sonst unbemerkt bleiben würden.

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

Die Ausgabe sieht wie folgt aus:

Schlussfolgerung

Datenbanken sind das Rückgrat moderner Anwendungen, und sie zu beherrschen ist eine unverzichtbare Fähigkeit für Entwickler. Wenn Sie lernen, mit Firebase zu interagieren, sei es durch die sofortige Synchronisierung von Realtime Database oder die leistungsstarken Abfragen von Firestore, haben Sie ein wichtiges Toolkit für die Erstellung dynamischer, datengesteuerter Anwendungen erschlossen. 

Dateiname	Beschreibung
firebase-users.mq5	Die Datei mit dem Code zur Durchführung von CRUD-Funktionen mit firestore.
Download_Infor.mq5	Die Datei mit dem Code für das Herunterladen von Informationen aus firestore und die Anzeige auf dem Chart.
Sending_Trading_Info.mq5	Die Datei, die den Code für die Übermittlung von Handelsinformationen an firestore enthält.