Entitäten und Entity-Definitionen: Die Bausteine von RDataCore

Willkommen bei RDataCore! Wenn du neu auf unserer Plattform bist, ist das Verständnis der Beziehung zwischen Entity-Definitionen und Entitäten die Grundlage für alles andere, was du bauen wirst. Stell es dir so vor: Wenn du ein Krankenhaus führst, ist die Entity-Definition die Patientenakten-Vorlage, die festlegt, welche Informationen du erfasst (Name, Geburtsdatum, Blutgruppe, Allergien), während Entitäten die tatsächlichen Patientendatensätze sind, die dieser Vorlage folgen.

In diesem Guide werden wir diese Kernkonzepte Schritt für Schritt durchgehen, die verschiedenen Feldtypen und Optionen erkunden und dir zeigen, wie Daten auf verschiedene Weise in deine RDataCore-Instanz fließen können. Am Ende wirst du ein solides Verständnis haben, wie du jeden Datentyp modellieren und verwalten kannst – von Kundenprofilen über IoT-Sensordaten bis hin zu Inventarartikeln.

Eine Entity-Definition ist das Schema oder die Vorlage, die die Struktur deiner Daten beschreibt. Bevor du irgendwelche Informationen in RDataCore speichern kannst, musst du definieren, wie diese Informationen aussehen. Hier legst du fest, welche Felder existieren, welchen Datentyp jedes Feld enthält, welche Einschränkungen gelten und wie die Daten validiert werden sollen.

Stell dir Entity-Definitionen als Schablonen oder Formen vor. Bevor du einen "Temperatursensor"-Datensatz erstellen kannst, brauchst du eine "Temperatursensor"-Entity-Definition, die festlegt:

• Welche Felder existieren (Standort, aktueller_Wert, Einheit, letztes_Kalibrierungsdatum, Batteriestand)
• Welchen Typ jedes Feld hat (Text, Dezimalzahl, Datum, Prozent)
• Welche Felder erforderlich vs. optional sind
• Welche Standardwerte verwendet werden
• Welche Felder für schnelle Suche indiziert werden sollen
• Welche Felder einzigartig sein müssen

Entity-Definitionen werden einmal erstellt und dann verwendet, um viele Entitäten zu erstellen. Eine einzelne "Rezept"-Definition kann verwendet werden, um Tausende von Rezepten zu speichern. Eine "Flugreservierung"-Definition dient als Vorlage für Millionen von Buchungen.

Wenn du eine Entity-Definition änderst, sorgt RDataCores Versionierungssystem (wird in einem kommenden Blog-Post behandelt) für reibungslose Übergänge ohne bestehende Daten zu beschädigen.

Du kannst auch visuelle und organisatorische Einstellungen an Entity-Definitionen konfigurieren, wie Icons zur einfachen Erkennung in der UI und Gruppierungen, um verwandte Definitionen zusammenzufassen.

Eine Entität in RDataCore ist ein einzelner Datensatz – eine Instanz strukturierter Daten, die etwas in der realen Welt repräsentiert. Das kann eine Patientenakte, ein Lagerstandort, ein Rezept, eine Flugbuchung, ein Sensorwert oder buchstäblich jede Information sein, die du erfassen möchtest.

Jede Entität gehört zu einer bestimmten Entity-Definition, die ihre Struktur bestimmt. Wenn du eine Entität erstellst, füllst du die von der Entity-Definition festgelegten Felder mit tatsächlichen Werten. Zum Beispiel könnte eine "Wetterstation"-Entität Werte wie stations_id: "WS-2847", standort: "Flughafen München", temperatur: 18.5 und luftfeuchtigkeit: 72 haben.

Entitäten sind die tatsächlichen Daten, mit denen du täglich arbeitest. Sie können:

• Manuell über die Benutzeroberfläche erstellt werden
• In großen Mengen aus CSV-Dateien oder externen Datenbanken importiert werden
• Automatisch durch Workflows generiert werden
• Via API von externen Anwendungen wie deiner E-Commerce-Plattform oder CRM gepusht werden
• Durch Webhook-Trigger von Diensten wie Stripe, Shopify oder benutzerdefinierten Systemen empfangen werden

Jede Entität erhält eine eindeutige UUID, Zeitstempel für Erstellung und Änderung und kann mithilfe von Pfaden in hierarchischen Strukturen organisiert werden. Um mehr über die Organisation von Entitäten zu erfahren, lies unseren Blog-Post über Entity-Hierarchien.

RDataCore unterstützt eine umfassende Palette von Feldtypen, um praktisch jede Datenstruktur zu modellieren. Beim Hinzufügen eines Felds zu einer Entity-Definition wählst du aus:

Die Wahl des richtigen Feldtyps ist wichtig, da sie die Validierung, Speichereffizienz und Darstellung der Daten in der UI beeinflusst. Zum Beispiel zeigt ein Date-Feld einen Datumspicker, während ein Enum-Feld ein Dropdown mit deinen vordefinierten Optionen anzeigt. Ein Float-Feld in einer "Laborergebnis"-Entity-Definition könnte Blutzuckerwerte speichern, während ein JSON-Feld in einer "Produkt"-Definition Variantenoptionen wie Größen und Farben speichern könnte.

Über den grundlegenden Feldtyp hinaus kann jedes Feld mit zusätzlichen Optionen konfiguriert werden, die steuern, wie Daten validiert und gespeichert werden:

Erforderlich vs. Optional: Markiere Felder als erforderlich, um sicherzustellen, dass Entitäten nicht ohne wesentliche Daten erstellt werden können. Eine "Krankenakte"-Entität sollte patient_id erfordern, während notfall_kontakt optional sein könnte.

Standardwerte: Lege Standardwerte fest, die beim Erstellen neuer Entitäten automatisch eingetragen werden. Nützlich für Statusfelder (Standard: "ausstehend"), Zeitstempel (Standard: aktuelles Datum) oder Zähler (Standard: 0). Ein "Support-Ticket" könnte Priorität standardmäßig auf "mittel" und Status auf "offen" setzen.

Eindeutigkeits-Constraints: Markiere Felder als eindeutig, um doppelte Werte über alle Entitäten dieses Typs zu verhindern. Perfekt für E-Mail-Adressen, SKUs, Seriennummern, Kennzeichen oder jeden Identifikator, der einmalig sein muss. Deine "Asset"-Definition könnte ein eindeutiges asset_tag-Feld haben.

Indizierung: Aktiviere Indizierung für Felder, nach denen du häufig suchst oder filterst. Indizierte Felder bieten dramatisch schnellere Abfrageleistung, besonders wichtig wenn dein Datensatz wächst. Häufige Kandidaten sind E-Mail-Adressen, Statusfelder, Daten, externe IDs und Fremdschlüssel. Wenn du ein "Sendungsverfolgung"-System baust, indiziere die tracking_nummer und status-Felder.

Validierungsregeln: Einige Feldtypen beinhalten automatische Validierung. E-Mail-Felder validieren das E-Mail-Format, URL-Felder validieren die URL-Struktur, und Enum-Felder akzeptieren nur vordefinierte Werte.

Diese Optionen arbeiten zusammen, um sicherzustellen, dass deine Daten sauber, konsistent und abfragbar bleiben. Eine gut gestaltete Entity-Definition mit passenden Constraints verhindert von vornherein, dass fehlerhafte Daten in dein System gelangen. Du kannst alle diese Optionen in unserer API-Dokumentation erkunden.

Über Felder hinaus haben Entity-Definitionen selbst mehrere Konfigurationsoptionen:

Icons: Weise deiner Entity-Definition ein Icon zur visuellen Erkennung in der UI zu. Beim Durchsuchen des Entity-Baums oder beim Betrachten von Listen helfen Icons, verschiedene Entity-Typen schnell zu identifizieren. Ein LKW-Icon für "Sendungen", ein Benutzer-Icon für "Kunden", ein Thermometer für "Temperaturmessungen", eine Box für "Inventarartikel". Wähle aus einer Icon-Bibliothek oder verwende eigene.

Gruppierungen: Organisiere verwandte Entity-Definitionen in Gruppen. Zum Beispiel könntest du eine "Logistik"-Gruppe mit Sendungs-, Lager- und Spediteur-Definitionen haben, eine "IoT"-Gruppe mit Sensor-, Messwert- und Alarm-Definitionen, und eine "CRM"-Gruppe mit Kontakt-, Firmen- und Deal-Definitionen. Gruppierungen erleichtern die Navigation in Systemen mit vielen Entity-Typen.

Entwurfsmodus: Entity-Definitionen unterstützen einen Entwurfsmodus, der es dir ermöglicht, dein Schema zu entwerfen und zu testen, bevor du es aktivierst. Im Entwurfsmodus kannst du Felder frei ändern, ohne Produktionsdaten zu beeinflussen. Sobald du zufrieden bist, veröffentliche die Definition, um sie für die Entity-Erstellung verfügbar zu machen.

Beschreibung: Füge eine Beschreibung hinzu, um den Zweck der Entity-Definition zu dokumentieren. Dies hilft Teammitgliedern zu verstehen, welche Daten die Definition erfassen soll. Eine "Klinische-Studien-Teilnehmer"-Definition könnte Hinweise zu DSGVO-Compliance-Anforderungen enthalten.

Versionierung (Standard-Funktion): RDataCore versioniert deine Entity-Definitionen automatisch. Wenn du eine veröffentlichte Definition änderst, erstellt das System eine neue Version unter Beibehaltung der Kompatibilität mit bestehenden Entitäten. Dies ist eine Standard-Funktion, die wir in einem kommenden Blog-Post über Entity-Definition-Versionierung ausführlich behandeln werden.

Der einfachste Weg, eine Entität zu erstellen, ist über die RDataCore-Admin-Oberfläche. Dies ist ideal für:

• Hinzufügen einzelner Datensätze (ein neuer Mitarbeiter, ein einzelnes Produkt)
• Testen deiner Entity-Definitionen vor Massenimporten
• Manuelle Dateneingabe für kleine Datensätze
• Schnelle Korrekturen oder Ergänzungen

Um eine Entität manuell zu erstellen:

1. Navigiere zur Entity-Definition, von der du eine Instanz erstellen möchtest
2. Klicke auf "Entität erstellen" (oder das Plus-Icon)
3. Fülle die erforderlichen und optionalen Felder aus
4. Setze optional einen Pfad für die hierarchische Organisation (siehe unseren Entity-Hierarchien-Guide)
5. Speichere die Entität

Das Formular validiert automatisch deine Eingabe basierend auf den Feldtypen und Constraints. Erforderliche Felder sind markiert, ungültige Daten werden hervorgehoben, und hilfreiche Fehlermeldungen führen dich zur Behebung von Problemen. Wenn du versuchst, einen doppelten Wert in einem eindeutigen Feld oder ein ungültiges E-Mail-Format einzugeben, informiert dich das System sofort.

Manuelles Erstellen ist großartig für kleine Mengen und Tests, aber RDataCore glänzt erst so richtig beim Handling von Massendaten durch automatisierte Prozesse. Für große Datensätze – denk an den Import von 50.000 Produkten aus deinem alten System oder die Synchronisation von Bestellungen von deiner E-Commerce-Plattform – wirst du Importe, Workflows oder die API verwenden wollen.

Manuelles Erstellen ist nur einer von vielen Wegen, wie Entitäten in deine RDataCore-Datenbank gelangen können. Für reales Datenmanagement wirst du typischerweise eine Kombination dieser Ansätze verwenden:

Import-Workflows: Importiere Daten aus CSV-, JSON- oder XML-Dateien. Definiere Feldmappings, Transformationsregeln und Zielpfade. Perfekt für die Migration bestehender Daten aus Legacy-Systemen, periodische Massenaktualisierungen von Partnern oder das Laden historischer Datensätze. Importiere 100.000 Kundendatensätze aus deinem alten CRM in Minuten.

API-Integration (Aktiv - Push): Deine Anwendungen können aktiv Daten an RDataCore über unsere REST-API pushen. Erstelle, aktualisiere und lösche Entitäten programmatisch. Ideal für Echtzeit-Integrationen, bei denen deine E-Commerce-Plattform neue Bestellungen pusht, dein IoT-Gateway Sensordaten sendet oder deine Mobile-App Benutzerprofile erstellt.

API-Integration (Passiv - Pull): RDataCore kann auch aktiv Daten von externen APIs nach Zeitplan oder Trigger abrufen. Ziehe Lagerbestände stündlich von der API deines Lieferanten, synchronisiere Kontaktaktualisierungen täglich von Salesforce oder hole Wechselkurse von einem Finanzdatenanbieter.

Webhooks: Empfange Echtzeit-Benachrichtigungen von externen Systemen. Wenn Ereignisse in anderen Plattformen auftreten – Stripe-Zahlung abgeschlossen, Shopify-Bestellung aufgegeben, GitHub-Issue erstellt – können Webhooks automatisch die Erstellung oder Aktualisierung von Entitäten auslösen. Kein Polling erforderlich.

Export-Workflows: Obwohl primär zum Herausholen von Daten gedacht, können Export-Workflows Teil einer bidirektionalen Synchronisation sein, bei der Daten in beide Richtungen zwischen RDataCore und anderen Systemen fließen.

Jede Methode integriert sich mit RDataCores Workflow-Engine, sodass du Transformationen, Validierungen und Geschäftslogik anwenden kannst, unabhängig davon, wie Daten in das System gelangen. Wir werden Workflow-Definitionen ausführlich in einem kommenden Blog-Post über Import/Export-Workflows behandeln.

RDataCore bietet eine umfassende Public API, die Drittanbieter-Integrationen und externen Zugriff auf deine Daten ermöglicht. Diese ist von der Admin-API getrennt und speziell für kontrollierten externen Zugriff konzipiert.

Mit der Public API kannst du:

• Partnern erlauben, bestimmte Entity-Typen abzufragen (Distributoren, die Lagerbestände prüfen)
• Kunden Zugriff auf ihre eigenen Daten ermöglichen (Bestellhistorie, Kontodetails)
• Benutzerdefinierte Anwendungen bauen, die aus RDataCore lesen (Mobile Apps, Dashboards)
• Öffentliche Datenportale erstellen (Produktkataloge, Veranstaltungslisten)

Der Zugriff wird durch API-Schlüssel und Pre-Shared-Tokens kontrolliert, was dir feingranulare Kontrolle darüber gibt, wer auf welche Daten zugreifen kann. Du kannst den Zugriff nach Entity-Definition einschränken, nach Feldern filtern und Operationen begrenzen (nur lesen vs. lesen-schreiben).

Die Public API folgt RESTful-Konventionen und enthält vollständige OpenAPI-Dokumentation. Du kannst die verfügbaren Endpunkte erkunden, Abfragen testen und Client-Code direkt aus der API-Dokumentation generieren.

Für Integrationsszenarien wird die Public API oft mit Webhooks kombiniert: Externe Systeme pushen Benachrichtigungen an RDataCore über Webhooks und rufen Daten über die API ab. Dies schafft einen robusten, bidirektionalen Datenfluss zwischen deinen Systemen.