QueryBuilder in Aktion Teil 1

Beim Erstellen von Anwendungen mit Node.js im Allgemeinen oder Total.js im Besonderen ist die effiziente Abfrage und Verwaltung von Daten unerlässlich. In diesem Blog behandeln wir die Durchführung grundlegender Datenoperationen mit dem Total.js QueryBuilder. In diesem ersten Teil werden grundlegende Konzepte vorgestellt, Kernaktionen wie das Einfügen und Abrufen von Daten demonstriert und praktische Beispiele vorgestellt, um Ihnen den Einstieg zu erleichtern.

Erste Schritte: QueryBuilder in Total.js erkunden

Der QueryBuilder von Total.js bietet eine leistungsstarke Abstraktionsschicht für die Interaktion mit verschiedenen Datenbanken durch Vorgänge wie Filtern, Einfügen, Aktualisieren und Abrufen von Daten. Egal, ob Sie an einer einfachen Anwendung arbeiten oder komplexe Abfragen verwalten, QueryBuilder bietet eine einfache und dennoch flexible ORM-Lösung für Node.js-Anwendungen.

Datenbankunterstützung und -implementierungen

QueryBuilder fungiert als mittlere Ebene und abstrahiert die Besonderheiten von Datenbank-Engines. Um es effektiv nutzen zu können, müssen Sie eine vorhandene Implementierung integrieren oder eine eigene erstellen, die Ihren Anforderungen entspricht. Total.js unterstützt mehrere Datenbank-Engines und gewährleistet so Flexibilität für verschiedene Anwendungsfälle.

Hier sind die aktuell verfügbaren Implementierungen:

• NoSQL Embedded Database (TextDB): Dies ist eine leichte, dateibasierte Datenbank, die im Total.js-Kern enthalten ist und sich perfekt für kleine Anwendungen oder Prototyping eignet.
• PostgreSQL: Nutzen Sie QueryBuilder mit einer der robustesten und funktionsreichsten relationalen Datenbanken.
• MySQL: Integrieren Sie diese weit verbreitete Datenbank für skalierbare und leistungsstarke Lösungen.
• SQLite: Nutzen Sie QueryBuilder mit dieser leichten, serverlosen Datenbank für schnelle Bereitstellungen oder eingebettete Anwendungen.

QueryBuilder einrichten

In diesem Leitfaden beginnen wir mit einer eingebetteten NoSQL (TextDB)-Datenbank, um zu zeigen, wie man Schemata definiert und grundlegende Aktionen wie das Abfragen, Einfügen und Aktualisieren von Daten durchführt. Am Ende verfügen Sie über die Fähigkeiten, diese Vorgänge für andere unterstützte Datenbank-Engines anzupassen.

Einrichten der Datenbank

Um effektiv zu lernen, erstellen wir eine Test-NoSQL-Datenbankdatei mit Beispielbenutzerdaten.

Datenbank-Setup: Erstellen Sie eine Datei „databases/users.nosql“, um Beispielbenutzerdatensätze zu speichern:

{"id": 2, "name": "Bob", "age": 30}
{"id": 3, "name": "Charlie", "age": 28}
{"id": 4, "name": "Diana", "age": 22}
{"id": 5, "name": "Edward", "age": 35}
{"id": 6, "name": "John", "age": 45}
{"id": 7, "name": "Fiona", "age": 27}
{"id": 8, "name": "George", "age": 29}
{"id": 9, "name": "Hannah", "age": 24}
{"id": 10, "name": "Isaac", "age": 31}
{"id": 11, "name": "Julia", "age": 26}

Gut zu wissen: Sie müssen die .nosql-Datei nicht manuell im Datenbankordner erstellen. Das Framework kann es während des Einfügevorgangs erstellen, wenn es nicht vorhanden ist. Der Inhalt der .nosql-Datei ist jedoch Klartext und es ist wichtig, seine Struktur zu verstehen. Vielleicht ist es nützlich, bestimmte Fälle zu beheben.

Schemadefinition: Erstellen Sie ein Schema mit Aktionen in schemas/users.js. Wir definieren Aktionen zum Auflisten, Abrufen und Einfügen von Benutzern.

Grundlegende QueryBuilder-Aktionen mit praktischen Beispielen

In schemas/users.js definieren wir Aktionen zum Auflisten und Einfügen von Benutzern. Dieses Schema verwendet QueryBuilder-Methoden, um Daten zu filtern, bestimmte Datensätze abzurufen und neue Benutzer zur Datenbank hinzuzufügen.

1. Auflisten von Benutzern mit Filtern
Wir beginnen mit der Definition einer Listenaktion, um Benutzer basierend auf Kriterien wie Name oder Alter abzurufen.

{"id": 2, "name": "Bob", "age": 30}
{"id": 3, "name": "Charlie", "age": 28}
{"id": 4, "name": "Diana", "age": 22}
{"id": 5, "name": "Edward", "age": 35}
{"id": 6, "name": "John", "age": 45}
{"id": 7, "name": "Fiona", "age": 27}
{"id": 8, "name": "George", "age": 29}
{"id": 9, "name": "Hannah", "age": 24}
{"id": 10, "name": "Isaac", "age": 31}
{"id": 11, "name": "Julia", "age": 26}

Verwendungsbeispiele:

Hier sind einige Variationen der Verwendung einer Liste zum Filtern von Benutzern.

• Nach Namen filtern:

NEWSCHEMA('Users', function(schema) {

    schema.action('list', {
        name: 'List users',
        query: 'page:Number, sort:String, name:String',
        params: 'id:String',
        action: async function($) {
            // Example: filter by name
            var users = await DATA.find('nosql/users').where('name', $.query.name).promise();
            $.callback(users); 
        }
    });
});

• Nur ​​Erstbenutzer abrufen:

var users = await ACTION('Users/list').where('name', 'John').promise();
console.log(users);

2. Abrufen eines Benutzers anhand seiner ID
Eine weitere nützliche Funktion ist das Abrufen eines Benutzers anhand seiner ID. Mit der .id()-Methode von QueryBuilder ist dies ganz einfach:

var user = await DATA.find('nosql/users').first().promise();
console.log(user);

Beispielverwendung:

var builder = DATA.find('nosql/users');
builder.id($.params.id);
// or builder.where('id', $.params.id);
$.callback(await builder.promise());

3. Einfügen eines neuen Benutzers
Als nächstes definieren wir eine Einfügeaktion, um neue Benutzer zur Datenbank hinzuzufügen.

var user = await ACTION('Users/list').params({ id: 5 }).promise();
console.log(user);  // Retrieves user with id 5

Diese Aktion fügt einen Benutzer zu „databases/users.nosql“ hinzu. So können Sie die Einfügeaktion aufrufen.

Verwendungsbeispiel:

schema.action('insert', {
    name: 'Inserting new users',
    input: '*name:String, age:Number',
    output: 'success:Boolean',
    action: function($, model) {
        DATA.insert('nosql/users', model).callback(function(err) {
            if (err) {
                console.error(err);
            } else {
                $.success(true);
            }
        });
    }
});

Praktische Anwendungsfälle: QueryBuilder in Aktion

1. Benutzer nach gefiltertem Namen abrufen

// in `definitions/test.js`
ON('ready', function() {
  var result = await ACTION('Users/insert', { name: 'Alice', age: 25 }).promise();
    console.log(result);
});

2. Benutzer anhand der ID abrufen

async function getUsersByName() {
    var users = await ACTION('Users/list').query({ name: 'Hannah' }).promise();
    console.log(users);
}
getUsersByName();

3. Fügen Sie einen neuen Benutzer ein und rufen Sie die aktualisierte Liste ab

async function getUserByID() {
    var user = await ACTION('Users/list').params({ id: 4 }).promise();
    console.log(user);
}
getUserByID();

Abschluss

In diesem ersten Teil von QueryBuilder in Action haben wir das Wesentliche behandelt: Erstellen einer grundlegenden NoSQL-Datenbank, Definieren von Schemaaktionen und Verwenden von QueryBuilder-Methoden zum Auflisten, Filtern, Abrufen und Einfügen von Benutzern. Wir haben praktische Codebeispiele für jeden Vorgang untersucht, um Ihnen zu helfen, zu verstehen, wie diese Konzepte in einem realen Szenario funktionieren.
Im nächsten Teil befassen wir uns mit fortgeschritteneren QueryBuilder-Methoden und komplexer Filterung, um Ihnen ein komplettes Toolkit für die effiziente Datenverwaltung in Total.js an die Hand zu geben.
Seien Sie gespannt auf QueryBuilder in Action Teil 2, in dem wir uns eingehender mit erweiterten Abfragetechniken befassen, um Ihre Total.js-Anwendungen zu optimieren!

Das obige ist der detaillierte Inhalt vonQueryBuilder in Aktion Teil 1. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!