Objektrelationale Zuordnung für fibjs

Installieren

1
npm install fib-orm

Prüfen

1
npm run ci

DBMS-Unterstützung

• MySQL und MariaDB
• SQLite

Merkmale

fib-orm fügt eine Reihe synchroner Versionsmethoden für das Node-orm-Objekt hinzu.

Einführung

Dies ist ein fibjs-Objektrelational-Mapping-Modul.

Ein Beispiel:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
var orm = require("fib-orm");

var db = orm.connectSync("mysql://username:password@host/database");
var Person = db.define("person", {
    name      : String,
    surname   : String,
    age       : Number, // FLOAT
    male      : Boolean,
    continent : [ "Europe", "America", "Asia", "Africa", "Australia", "Antartica" ], // ENUM type
    photo     : Buffer, // BLOB/BINARY
    data      : Object // JSON encoded
}, {
    methods: {
        fullName: function () {
            return this.name + ' ' + this.surname;
        }
    },
    validations: {
        age: orm.enforce.ranges.number(18, undefined, "under-age")
    }
});

// add the table to the database
db.syncSync();

// add a row to the person table
Person.createSync({ id: 1, name: "John", surname: "Doe", age: 27 });

// query the person table by surname
var people = Person.findSync({ surname: "Doe" });
// SQL: "SELECT * FROM person WHERE surname = 'Doe'"

console.log("People found: %d", people.length);
console.log("First person: %s, age %d", people[0].fullName(), people[0].age);

people[0].age = 16;
people[0].saveSync();

Die node.js-Version sieht so aus:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
var orm = require("orm");

orm.connect("mysql://username:password@host/database", function (err, db) {
  if (err) throw err;

    var Person = db.define("person", {
        name      : String,
        surname   : String,
        age       : Number, // FLOAT
        male      : Boolean,
        continent : [ "Europe", "America", "Asia", "Africa", "Australia", "Antartica" ], // ENUM type
        photo     : Buffer, // BLOB/BINARY
        data      : Object // JSON encoded
    }, {
        methods: {
            fullName: function () {
                return this.name + ' ' + this.surname;
            }
        },
        validations: {
            age: orm.enforce.ranges.number(18, undefined, "under-age")
        }
    });

    // add the table to the database
    db.sync(function(err) {
        if (err) throw err;

        // add a row to the person table
        Person.create({ id: 1, name: "John", surname: "Doe", age: 27 }, function(err) {
            if (err) throw err;

                // query the person table by surname
                Person.find({ surname: "Doe" }, function (err, people) {
                    // SQL: "SELECT * FROM person WHERE surname = 'Doe'"
                    if (err) throw err;

                    console.log("People found: %d", people.length);
                    console.log("First person: %s, age %d", people[0].fullName(), people[0].age);

                    people[0].age = 16;
                    people[0].save(function (err) {
                        // err.msg = "under-age";
                });
            });

        });
    });
});

Dokumentation

Fibjs hat keine neuen Funktionen hinzugefügt, die Entwicklung von Dokumenten kann sich auf Node-ORM beziehen, es muss nur der asynchrone Aufruf in die synchrone Version geändert werden. Wiki .

Einstellungen

Siehe Informationen im Wiki .

Verbinden

Siehe Informationen im Wiki .

Modelle

Ein Modell ist eine Abstraktion über eine oder mehrere Datenbanktabellen. Modelle unterstützen Assoziationen (mehr unten). Es wird davon ausgegangen, dass der Name des Modells mit dem Tabellennamen übereinstimmt.

Modelle unterstützen Verhaltensweisen für den Zugriff auf und die Bearbeitung von Tabellendaten.

Modelle definieren

Siehe Informationen im Wiki .

Properties

Siehe Informationen im Wiki .

Instance Methods

Werden bei der Modelldefinition übergeben.

1
2
3
4
5
6
7
8
9
10
11
12
13
var Person = db.define('person', {
    name    : String,
    surname : String
}, {
    methods: {
        fullName: function () {
            return this.name + ' ' + this.surname;
        }
    }
});

var person = Person.getSync(4);
console.log( person.fullName() );

Model Methods

Werden direkt am Modell definiert.

1
2
3
4
5
6
7
8
9
var Person = db.define('person', {
    name    : String,
    height  : { type: 'integer' }
});
Person.tallerThan = function(height) {
    return this.findSync({ height: orm.gt(height) });
};

var tallPeople = Person.tallerThan( 192);

Laden von Modellen [NICHT UNTERSTÜTZT]

Modelle können sich in separaten Modulen befinden. Stellen Sie einfach sicher, dass das Modul, das die Modelle enthält, module.exports verwendet, um eine Funktion zu veröffentlichen, die die Datenbankverbindung akzeptiert, und laden Sie dann Ihre Modelle nach Ihren Wünschen.

Hinweis: Mit dieser Technik können kaskadierende Lasten entstehen.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// your main file (after connecting)
db.loadSync("./models");
// loaded!
var Person = db.models.person;
var Pet    = db.models.pet;

// models.js
module.exports = function (db) {
    db.loadSync("./models-extra");
    db.define('person', {
        name : String
    });
};

// models-extra.js
module.exports = function (db) {
    db.define('pet', {
        name : String
    });
};

Modelle synchronisieren

Siehe Informationen im Wiki .

Modelle fallen lassen

Siehe Informationen im Wiki .

Erweiterte Optionen

ORM2 ermöglicht Ihnen einige erweiterte Optimierungen an Ihren Modelldefinitionen. Sie können diese über die Einstellungen oder im Aufruf von konfigurieren, definewenn Sie das Modell einrichten.

Beispielsweise verfügt jede Modellinstanz über eine eindeutige ID in der Datenbank. Diese Tabellenspalte wird automatisch hinzugefügt und heißt standardmäßig „id“.
Wenn Sie eine eigene key: trueSpalte definieren, wird „id“ nicht hinzugefügt:

1
2
3
4
5
6
7
8
9
10
11
12
var Person = db.define("person", {
    personId : { type: 'serial', key: true },
    name     : String
});

// You can also change the default "id" property name globally:
db.settings.set("properties.primary_key", "UID");

// ..and then define your Models
var Pet = db.define("pet", {
    name : String
});

Das Haustiermodell wird zwei Spalten haben, eine UIDund eine name.

Es ist auch möglich, zusammengesetzte Schlüssel zu haben:

1
2
3
4
var Person = db.define("person", {
    firstname : { type: 'text', key: true },
    lastname  : { type: 'text', key: true }
});

Andere Optionen:

• identityCache : (Standard: false) Legen Sie fest true, dass der Identitätscache ( Singletons ) aktiviert ist, oder legen Sie einen Zeitüberschreitungswert (in Sekunden) fest.
• autoSave : (Standard: false) Legen Sie fest, dass trueeine Instanz direkt nach dem Ändern einer Eigenschaft gespeichert wird.
• autoFetch : (Standard: false) Legen Sie fest, truedass beim Abrufen einer Instanz aus der Datenbank Assoziationen abgerufen werden.
• autoFetchLimit: (Standard: 1) Wenn autoFetchaktiviert, definiert dies, wie viele Rahmen (Assoziationen von Assoziationen) automatisch abgerufen werden sollen.

Haken

Siehe Informationen im Wiki .

Gegenstände finden

Model.getSync(id, [ options ])

Um ein bestimmtes Element aus der Datenbank abzurufen, verwenden Sie Model.get.

1
2
var person = Person.getSync(123);
// finds person with id = 123

Model.findSync([ conditions ] [, options ] [, limit ] [, order ])

Beim Suchen nach einem oder mehreren Elementen gibt es mehrere Optionen, jedes einzelne kann in keiner bestimmten Parameterreihenfolge angegeben werden. Es optionsmuss nur danach stehen conditions(auch wenn es sich um ein leeres Objekt handelt).

1
2
var people = Person.findSync({ name: "John", surname: "Doe" }, 3);
// finds people with name='John' AND surname='Doe' and returns the first 3

Wenn Sie die Ergebnisse sortieren müssen, weil Sie sie einschränken oder einfach nur, weil Sie eine Sortierung wünschen, gehen Sie wie folgt vor:

1
2
3
4
5
6
var people = Person.findSync({ surname: "Doe" }, "name");
// finds people with surname='Doe' and returns sorted by name ascending

people = Person.findSync({ surname: "Doe" }, [ "name", "Z" ]);
// finds people with surname='Doe' and returns sorted by name descending
// ('Z' means DESC; 'A' means ASC - default)

Es gibt weitere Optionen, die Sie übergeben können, um etwas zu finden. Diese Optionen werden in einem zweiten Objekt übergeben:

1
2
var people = Person.findSync({ surname: "Doe" }, { offset: 2 });
// finds people with surname='Doe', skips the first 2 and returns the others

Sie können bei der Suche auch unformatiertes SQL verwenden. Dies wird im Abschnitt „Verkettung“ weiter unten dokumentiert.

Model.countSync([ conditions])

Wenn Sie nur die Anzahl der Elemente zählen möchten, die einer Bedingung entsprechen, können Sie diese einfach verwenden, .count()anstatt sie alle zu finden und zu zählen. Dadurch wird der Datenbankserver tatsächlich angewiesen, eine Zählung durchzuführen (dies geschieht nicht im Knotenprozess selbst). ).

1
2
var count = Person.countSync({ surname: "Doe" });
console.log("We have %d Does in our db", count);

Model.existsSync([ conditions])

Ähnlich wie bei .count()prüft diese Methode lediglich, ob die Anzahl größer als Null ist oder nicht.

1
2
var exists = Person.existsSync({ surname: "Doe" });
console.log("We %s Does in our db", exists ? "have" : "don't have");

Aggregating Functions

An Arrayvon Eigenschaften kann übergeben werden, um nur wenige Eigenschaften auszuwählen. An Objectwird auch akzeptiert, um Bedingungen zu definieren.

Hier ist ein Beispiel zur Veranschaulichung der Verwendung .groupBy():

1
2
3
//The same as "select avg(weight), age from person where country='someCountry' group by age;"
var stats = Person.aggregate(["age"], { country: "someCountry" }).avg("weight").groupBy("age").getSync();
// stats is an Array, each item should have 'age' and 'avg_weight'

Basismethoden .aggregate()_

• .limit(): Sie können eine Zahl als Grenzwert oder zwei Zahlen als Offset bzw. Grenzwert übergeben
• .order(): gleich wieModel.find().order()

Zusätzliche .aggregate()Methoden

• min
• max
• avg
• sum
• count(Es gibt eine Abkürzung dazu – Model.count)

Je nach Treiber gibt es weitere Aggregatfunktionen (z. B. mathematische Funktionen).

Chaining

Wenn Sie eine weniger komplizierte Syntax bevorzugen, können Sie eine Verkettung durchführen .find(), indem Sie keinen Callback-Parameter angeben.

1
2
3
var people = Person.find({ surname: "Doe" }).limit(3).offset(2).only("name", "surname").runSync();
// finds people with surname='Doe', skips first 2 and limits to 3 elements,
// returning only 'name' and 'surname' properties

Wenn Sie nur eine oder zwei Eigenschaften überspringen möchten, können Sie .omit()stattdessen aufrufen .only.

Die Verkettung ermöglicht kompliziertere Abfragen. Beispielsweise können wir durch die Angabe von benutzerdefiniertem SQL suchen:

1
Person.find({ age: 18 }).where("LOWER(surname) LIKE ?", ['dea%']).allSync( ... );

Es ist keine gute Praxis, SQL-Parameter manuell zu maskieren, da dies fehleranfällig ist und Ihre Anwendung der SQL-Injection aussetzt. Die ?Syntax kümmert sich um die Escape-Funktion, indem sie das Fragezeichen in der Abfrage sicher durch die bereitgestellten Parameter ersetzt. Sie können auch mehrere whereKlauseln als verketten erforderlich.

.find, .where& .allmachen das Gleiche; sie sind alle austauschbar und verkettbar.

Sie können auch orderoder orderRaw:

1
2
3
Person.find({ age: 18 }).order('-name').allSync( ... );
// see the 'Raw queries' section below for more details
Person.find({ age: 18 }).orderRaw("?? DESC", ['age']).allSync( ... );

Sie können auch verketten und am Ende nur die Anzahl ermitteln. In diesem Fall werden Offset, Limit und Reihenfolge ignoriert.

1
2
var people = Person.find({ surname: "Doe" }).countSync();
// people = number of people with surname="Doe"

Außerdem ist die Option zum Entfernen der ausgewählten Elemente verfügbar. Beachten Sie, dass bei einer verketteten Entfernung keine Hooks ausgeführt werden.

1
2
Person.find({ surname: "Doe" }).removeSync();
// Does gone..

Sie können auch mithilfe gängiger Array-Traversal-Methoden Änderungen an Ihren Instanzen vornehmen und am Ende alles speichern. [NICHT UNTERSTÜTZT]

1
2
3
4
5
6
7
8
9
10
11
12
13
Person.find({ surname: "Doe" }).each(function (person) {
    person.surname = "Dean";
}).save(function (err) {
    // done!
});

Person.find({ surname: "Doe" }).each().filter(function (person) {
    return person.age >= 18;
}).sort(function (person1, person2) {
    return person1.age < person2.age;
}).get(function (people) {
    // get all people with at least 18 years, sorted by age
});

Natürlich können Sie dies direkt auf tun .find(), aber für einige kompliziertere Aufgaben kann dies sehr nützlich sein.

Model.find()gibt kein Array zurück, sodass Sie nicht einfach direkt verketten können. Um mit der Verkettung zu beginnen, müssen Sie aufrufen ( .each()mit einem optionalen Rückruf, wenn Sie die Liste durchlaufen möchten). Sie können dann die allgemeinen Funktionen .filter()und mehr als einmal verwenden..sort().forEach()

Am Ende (oder während des Prozesses...) können Sie anrufen:

• .countSync()wenn Sie nur wissen möchten, wie viele Artikel es gibt;
• .getSync()um die Liste abzurufen;
• .saveSync()um alle Elementänderungen zu speichern.

Bedingungen

Bedingungen werden als Objekt definiert, bei dem jeder Schlüssel eine Eigenschaft (Tabellenspalte) ist. Alle Schlüssel sollen durch die logische Verknüpfung verkettet werden AND. Es wird davon ausgegangen, dass Werte genau übereinstimmen, es sei denn, Sie übergeben ein Array. In diesem Fall wird es berücksichtigt eine Liste zum Vergleichen der Immobilie.

1
2
{ col1: 123, col2: "foo" } // `col1` = 123 AND `col2` = 'foo'
{ col1: [ 1, 3, 5 ] } // `col1` IN (1, 3, 5)

Wenn Sie andere Vergleiche benötigen, müssen Sie ein spezielles Objekt verwenden, das von einigen Hilfsfunktionen erstellt wird. Hier einige Beispiele zur Beschreibung:

1
2
3
4
5
6
7
8
9
10
11
{ col1: orm.eq(123) } // `col1` = 123 (default)
{ col1: orm.ne(123) } // `col1` <> 123
{ col1: orm.gt(123) } // `col1` > 123
{ col1: orm.gte(123) } // `col1` >= 123
{ col1: orm.lt(123) } // `col1` < 123
{ col1: orm.lte(123) } // `col1` <= 123
{ col1: orm.between(123, 456) } // `col1` BETWEEN 123 AND 456
{ col1: orm.not_between(123, 456) } // `col1` NOT BETWEEN 123 AND 456
{ col1: orm.like(12 + "%") } // `col1` LIKE '12%'
{ col1: orm.not_like(12 + "%") } // `col1` NOT LIKE '12%'
{ col1: orm.not_in([1, 4, 8]) } // `col1` NOT IN (1, 4, 8)

Rohabfragen

1
2
3
4
5
6
7
8
9
10
11
12
13
var data = db.driver.execQuerySync("SELECT id, email FROM user")

// You can escape identifiers and values.
// For identifier substitution use: ??
// For value substitution use: ?
var data = db.driver.execQuerySync(
  "SELECT user.??, user.?? FROM user WHERE user.?? LIKE ? AND user.?? > ?",
  ['id', 'name', 'name', 'john', 'id', 55])

// Identifiers don't need to be scaped most of the time
var data = db.driver.execQuerySync(
  "SELECT user.id, user.name FROM user WHERE user.name LIKE ? AND user.id > ?",
  ['john', 55])

Identity pattern

Sie können das Identitätsmuster verwenden (standardmäßig deaktiviert). Wenn es aktiviert ist, führen mehrere unterschiedliche Abfragen zum gleichen Ergebnis – Sie erhalten das gleiche Objekt. Wenn Sie andere Systeme haben, die Ihre Datenbank ändern können, oder Sie ein Handbuch aufrufen müssen Bei SQL-Abfragen sollten Sie diese Funktion nicht verwenden. Es ist außerdem bekannt, dass sie einige Probleme mit komplexen Autofetch-Beziehungen verursacht. Die Verwendung erfolgt auf eigene Gefahr.

Es kann pro Modell aktiviert/deaktiviert werden:

1
2
3
4
5
var Person = db.define('person', {
    name          : String
}, {
    identityCache : true
});

und auch weltweit:

1
2
var db = orm.connectSync('...');
db.settings.set('instance.identityCache', true);

Der Identitätscache kann so konfiguriert werden, dass er nach einem bestimmten Zeitraum abläuft, indem eine Zahl anstelle eines booleschen Werts übergeben wird. Die Zahl wird als Cache-Timeout in Sekunden betrachtet (Sie können Gleitkomma verwenden).

Hinweis : Eine Ausnahme beim Caching besteht darin, dass es nicht verwendet wird, wenn eine Instanz nicht gespeichert wird. Wenn Sie beispielsweise eine Person abrufen und sie dann ändern, wird sie zwar nicht gespeichert, aber nicht aus dem Cache übergeben.

Artikel erstellen

Model.createSync(items)

Um neue Elemente in die Datenbank einzufügen, verwenden Sie Model.create.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var items = Person.createSync([
    {
        name: "John",
        surname: "Doe",
        age: 25,
        male: true
    },
    {
        name: "Liza",
        surname: "Kollan",
        age: 19,
        male: false
    }
]);
// items - array of inserted items

Elemente aktualisieren

Jedes zurückgegebene Element verfügt über die Eigenschaften, die für das Modell definiert wurden, sowie über einige Methoden, mit denen Sie jedes Element ändern können.

1
2
3
4
5
var John = Person.getSync(1);
John.name = "Joe";
John.surname = "Doe";
John.saveSync();
console.log("saved!");

Das Aktualisieren und anschließende Speichern einer Instanz kann in einem einzigen Aufruf erfolgen:

1
2
3
var John = Person.getSync(1);
John.saveSync({ name: "Joe", surname: "Doe" });
console.log("saved!");

Wenn Sie eine Instanz entfernen möchten, gehen Sie einfach wie folgt vor:

1
2
3
4
// you could do this without even fetching it, look at Chaining section above
var John = Person.getSync(1);
John.removeSync();
console.log("removed!");

Validierungen

Siehe Informationen im Wiki .

Verbände

Eine Assoziation ist eine Beziehung zwischen einer oder mehreren Tabellen.

hasOne

Ist eine Viele-zu-Eins- Beziehung. Es ist dasselbe wie „ gehört zu“.
Beispiel: Animal.hasOne('owner', Person)„
Tier kann nur einen Besitzer haben, aber Person kann viele Tiere haben.
Die Eigenschaft „Tier“ wird owner_idautomatisch hinzugefügt.

Folgende Funktionen werden verfügbar:

1
2
3
4
animal.getOwnerSync()         // Gets owner
animal.setOwnerSync(person) // Sets owner_id
animal.hasOwnerSync()         // Checks if owner exists
animal.removeOwnerSync()                // Sets owner_id to 0

Kettenfund

Die hasOne-Assoziation ist auch Chain-Find-kompatibel. Anhand des obigen Beispiels können wir dies tun, um auf eine neue Instanz eines ChainFind-Objekts zuzugreifen:

1
Animal.findByOwner({ /* options */ })

Rückwärtszugriff

1
Animal.hasOne('owner', Person, {reverse: 'pets'})

wird Folgendes hinzufügen:

1
2
3
4
5
6
// Instance methods
person.getPetsSync(function..)
person.setPetsSync(cat, function..)

// Model methods
Person.findByPets({ /* options */ }) // returns ChainFind object

hasMany

Ist eine Viele-zu-Viele- Beziehung (einschließlich Join-Tabelle).
Beispiel: Patient.hasMany('doctors', Doctor, { why: String }, { reverse: 'patients', key: true }).
Der Patient kann viele verschiedene Ärzte haben. Jeder Arzt kann viele verschiedene Patienten haben.

Dadurch wird eine Join-Tabelle erstellt, patient_doctorswenn Sie Folgendes aufrufen Patient.sync():

Spaltenname	Typ
Patienten ID	Ganzzahl (zusammengesetzter Schlüssel)
doctor_id	Ganzzahl (zusammengesetzter Schlüssel)
Warum	varchar(255)

Folgende Funktionen stehen zur Verfügung:

1
2
3
4
5
6
7
8
9
10
11
12
patient.getDoctorsSync()           // List of doctors
patient.addDoctorsSync(docs)    // Adds entries to join table
patient.setDoctorsSync(docs)    // Removes existing entries in join table, adds new ones
patient.hasDoctorsSync(docs)    // Checks if patient is associated to specified doctors
patient.removeDoctorsSync(docs) // Removes specified doctors from join table

doctor.getPatientsSync()
etc...

// You can also do:
patient.doctors = [doc1, doc2];
patient.saveSync()

So verknüpfen Sie einen Arzt mit einem Patienten:

1
patient.addDoctorSync(surgeon, {why: "remove appendix"})

{patient_id: 4, doctor_id: 6, why: "remove appendix"}was zur Join-Tabelle hinzugefügt wird .

getAccessor

Dieser Accessor in dieser Art von Zuordnung gibt einen ChainFindRückruf zurück, wenn er nicht übergeben wird. Das bedeutet, dass Sie Dinge tun können wie:

1
2
var doctors = patient.getDoctors().order("name").offset(1).runSync());
// ... all doctors, ordered by name, excluding first one

extendsTo

Wenn Sie möglicherweise optionale Eigenschaften in verschiedene Tabellen oder Sammlungen aufteilen möchten, befindet sich jede Erweiterung in einer neuen Tabelle, wobei die eindeutige Kennung jeder Zeile die Hauptmodellinstanz-ID ist. Beispiel:

1
2
3
4
5
6
7
var Person = db.define("person", {
    name : String
});
var PersonAddress = Person.extendsTo("address", {
    street : String,
    number : Number
});

Dadurch wird eine Tabelle personmit den Spalten idund erstellt name. Die Erweiterung erstellt eine Tabelle person_addressmit den Spalten person_id, streetund number. Die im PersonModell verfügbaren Methoden ähneln einer hasOne Assoziation. In diesem Beispiel könnten Sie .getAddress(cb), .setAddress(Address, cb), . aufrufen.

Hinweis: Sie müssen das Ergebnis nicht aus speichern Person.extendsTo. Es gibt ein erweitertes Modell zurück. Sie können es verwenden, um diese erweiterte Tabelle direkt abzufragen (und sogar das zugehörige Modell zu finden), aber das bleibt Ihnen überlassen. Wenn Sie nur darauf zugreifen möchten Wenn Sie das Originalmodell verwenden, können Sie die Rückgabe einfach verwerfen.

Examples & options

Wenn Sie eine Beziehung von 1 zu n haben, sollten Sie die hasOneAssoziation (gehört zu) verwenden.

1
2
3
4
5
6
7
8
9
10
11
12
13
var Person = db.define('person', {
    name : String
});
var Animal = db.define('animal', {
    name : String
});
Animal.hasOne("owner", Person); // creates column 'owner_id' in 'animal' table

// get animal with id = 123
var animal = Animal.getSync(123);
// animal is the animal model instance, if found
var person = animal.getOwnerSync();
// if animal has really an owner, person points to it

Sie können das owner_idFeld in der Datenbank als erforderlich markieren, indem Sie die requiredOption angeben:

1
Animal.hasOne("owner", Person, { required: true });

Wenn ein Feld nicht erforderlich ist, aber validiert werden soll, auch wenn es nicht vorhanden ist, geben Sie die alwaysValidateOption an. (Dies kann beispielsweise passieren, wenn die Validierung eines Nullfelds von anderen Feldern im Datensatz abhängt.)

1
Animal.hasOne("owner", Person, { required: false, alwaysValidate: true });

Wenn Sie lieber einen anderen Namen für das Feld verwenden möchten (owner_id), können Sie diesen Parameter in den Einstellungen ändern.

1
db.settings.set("properties.association_key", "{field}_{name}"); // {name} will be replaced by 'owner' and {field} will be replaced by 'id' in this case

Hinweis: Dies muss vor der Angabe der Zuordnung erfolgen.

Die hasManyAssoziationen können in der Assoziationstabelle zusätzliche Eigenschaften haben.

1
2
3
4
5
6
7
8
9
10
11
var Person = db.define('person', {
    name : String
});
Person.hasMany("friends", {
    rate : Number
}, {}, { key: true });

var John = Person.getSync(123);
var friends = John.getFriendsSync();
// assumes rate is another column on table person_friends
// you can access it by going to friends[N].extra.rate

Wenn Sie möchten, können Sie aktivieren autoFetch. Auf diese Weise werden Assoziationen automatisch abgerufen, wenn Sie Instanzen eines Modells abrufen oder finden.

1
2
3
4
5
6
7
8
9
10
11
12
var Person = db.define('person', {
  name : String
});
Person.hasMany("friends", {
    rate : Number
}, {
    key       : true, // Turns the foreign keys in the join table into a composite key
    autoFetch : true
});

var John = Person.getSync(123);
// no need to do John.getFriends() , John already has John.friends Array

Sie können diese Option auch global statt pro Zuordnung definieren.

1
2
3
4
5
6
7
8
9
10
var Person = db.define('person', {
    name : String
}, {
    autoFetch : true
});
Person.hasMany("friends", {
    rate : Number
}, {
  key: true
});

Assoziationen können mithilfe der reverseOption Aufrufe an das zugehörige Modell durchführen. Wenn Sie beispielsweise eine Assoziation von ModelA zu ModelB haben, können Sie in ModelB einen Accessor erstellen, um Instanzen von ModelA abzurufen. Verwirrend? Sehen Sie sich das nächste Beispiel an.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
var Pet = db.define('pet', {
    name : String
});
var Person = db.define('person', {
    name : String
});
Pet.hasOne("owner", Person, {
    reverse : "pets"
});

var pets = Person(4).getPetsSync();
// although the association was made on Pet,
// Person will have an accessor (getPets)
//
// In this example, ORM will fetch all pets
// whose owner_id = 4

Dies ist umso sinnvoller, wenn Sie hasManyAssoziationen haben, da Sie die vielen-zu-vielen- Assoziationen von beiden Seiten aus verwalten können.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
var Pet = db.define('pet', {
    name : String
});
var Person = db.define('person', {
    name : String
});
Person.hasMany("pets", Pet, {
    bought  : Date
}, {
    key     : true,
    reverse : "owners"
});

Person(1).getPetsSync(...);
Pet(2).getOwnersSync(...);

Transaktionsunterstützung

Sie können die Transaktionsfunktion auf niedriger Ebene verwenden, um die Datenbanktransaktion zu verarbeiten.

1
2
3
4
5
6
db.begin();
...
if(err)
    db.rollback();
else
    db.commit();

Oder Sie können trans verwenden, um es einfach zu verarbeiten.

1
2
3
4
var result = db.trans(() => {
    ...
    return result;
});

Hinzufügen externer Datenbankadapter

Um einen externen Datenbankadapter hinzuzufügen orm, rufen Sie die addAdapterMethode auf und übergeben Sie den Alias, der für die Verbindung mit diesem Adapter verwendet werden soll, sowie den Konstruktor für den Adapter:

1
require('orm').addAdapter('cassandra', CassandraAdapter);

Sehenthe documentation for creating adaptersfür mehr Details.