Tolles Community-Modul

Objektrelationales Mapping für fibjs

Build-Status

Installieren

1
npm install fib-orm

Prüfung

1
npm run ci

DBMS-Unterstützung

  • MySQL & MariaDB
  • SQLite

Eigenschaften

fib-orm fügt einen Satz synchroner Versionsmethoden zum node-orm-Objekt hinzu.

Einführung

Dies ist ein objektrelationales Mapping-Modul von fibjs.

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 wie folgt:

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 nicht neue Funktionen hinzufügen, die Entwicklung von Dokumenten - Knoten-orm beziehen kann, muß nur den asynchronen Aufruf synchrone Version ändern. Wiki .

die Einstellungen

Siehe Informationen im Wiki .

Anschließen

Siehe Informationen im Wiki .

Modelle

Ein Modell stellt eine Abstraktion über eine oder mehrere Datenbanktabellen dar. Modelle unterstützen Assoziationen (mehr dazu weiter unten). Es wird angenommen, 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 [KEINE UNTERSTÜTZUNG]

Modelle können in separaten Modulen sein. 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 Belieben.

Hinweis: Mit dieser Technik können Sie kaskadierende Lasten haben.

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

Synchronisieren von Modellen

Siehe Informationen im Wiki .

Modelle fallen lassen

Siehe Informationen im Wiki .

Erweiterte Optionen

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

Beispielsweise hat jede Modellinstanz eine eindeutige ID in der Datenbank. Diese Tabellenspalte wird automatisch hinzugefügt und wird standardmäßig "id" genannt.
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 hat 2 Spalten, 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:) falseLegen Sie fest, trueum den Identitätscache ( Singletons ) zu aktivieren oder einen Zeitüberschreitungswert (in Sekunden) festzulegen;
  • autoSave : (Standard:) falseLegen Sie fest, dass trueeine Instanz direkt nach dem Ändern einer Eigenschaft gespeichert wird;
  • autoFetch : (Standard :) falseSetzen Sie es trueauf Assoziationen beim Abrufen einer Instanz aus der Datenbank;
  • autoFetchLimit: (Standard :) 1Wenn autoFetchaktiviert, definiert dies, wie viele Reifen (Assoziationen von Assoziationen) automatisch abgerufen werden sollen.

Haken

Siehe Informationen im Wiki .

Artikel finden

Model.getSync(id, [ options ])

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

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

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

Das Finden eines oder mehrerer Elemente hat mehrere Optionen, jedes kann in keiner bestimmten Parameterreihenfolge angegeben werden options, sondern nur nach conditions(auch wenn es ein leeres Objekt ist).

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 Einschränkungen haben oder nur, weil Sie sie sortiert haben möchten, 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 Roh-SQL verwenden, was im Abschnitt Verkettung unten dokumentiert ist .

Model.countSync([ conditions])

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

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()dieser Methode wird nur überprüft, 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

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

Hier ist ein Beispiel, um die Verwendung zu veranschaulichen .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'

.aggregate()Basismethoden

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

Zusätzliche .aggregate()Methoden

  • min
  • max
  • avg
  • sum
  • count(dafür gibt es eine Abkürzung- Model.count)

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

Chaining

Wenn Sie eine weniger komplizierte Syntax bevorzugen, können Sie verketten, .find()indem Sie keinen Rückrufparameter 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()anstelle von aufrufen .only.

Die Verkettung ermöglicht kompliziertere Abfragen. Wir können beispielsweise suchen, indem wir benutzerdefiniertes SQL angeben:

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

Es ist eine schlechte Praxis manuell SQL - Parameter , wie es die fehleranfällig zu entkommen und macht Ihre Anwendung SQL - Injektion. Die ?Syntax Pflege für Sie zu entkommen nimmt, durch sicher zur Verfügung gestellt , die Fragezeichen in der Abfrage mit den Parametern zu ersetzen. Sie können auch mehrere Kette whereKlauseln erforderlich.

.find, .where& .allmachen dasselbe; sie sind alle austauschbar und verkettebar.

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 Zählung erhalten.In diesem Fall werden Offset, Limit und Order 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 ein verkettetes Entfernen keine Hooks ausführt.

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

Sie können Ihre Instanzen auch mit gängigen Array-Traversal-Methoden ändern und am Ende alles speichern.

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 die Verkettung zu starten, müssen Sie aufrufen .each()(mit einem optionalen Rückruf,wenn Sie die Liste durchlaufen möchten).Sie können dann die allgemeinen Funktionen verwenden .filter(), .sort()und .forEach()mehr als einmal.

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 Artikeländerungen zu speichern.

Bedingungen

Bedingungen sind als ein Objekt definiert, bei dem jeder Schlüssel eine Eigenschaft (Tabellenspalte) ist. Alle Schlüssel sollen durch das logische verkettet werden AND. Werte werden als genau übereinstimmend betrachtet, es sei denn, Sie übergeben ein Array. In diesem Fall wird es berücksichtigt eine Liste zum Vergleich 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 wurde.Hier sind einige Beispiele, um dies zu beschreiben:

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 aktiviert, führen mehrere verschiedene Abfragen zum gleichen Ergebnis - Sie erhalten dasselbe Objekt. Wenn Sie andere Systeme haben, die Ihre Datenbank ändern können, oder wenn Sie ein Handbuch aufrufen müssen SQL-Abfragen sollten Sie dieses Feature nicht verwenden. Es ist auch bekannt, dass es einige Probleme mit komplexen Autofetch-Beziehungen verursacht. Verwenden Sie es 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äts-Cache kann so konfiguriert werden, dass er nach einer bestimmten Zeit abläuft, indem statt eines booleschen Werts eine Zahl übergeben wird.Die Zahl wird als Cache-Timeout in Sekunden betrachtet (Sie können Gleitkommazahlen 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 dann ändern, wird sie nicht vom Cache übergeben, während sie nicht gespeichert wird.

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

Aktualisieren von Elementen

Jedes zurückgegebene Element hat die Eigenschaften, die für das Modell definiert wurden, sowie 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 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

Ein IS to One VIELE Es ist Beziehung zu den gleichen, AS. Gehört.
Beispiel: Animal.hasOne('owner', Person).
. Tier nur einen Eigentümer haben , haben kann, haben viele CAN haben aber die Person Tiere
Tier von Will The haben haben owner_idEigenschaft automatisch hinzugefügt.

Folgende Funktionen werden verfügbar sein:

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

Kettensuche

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

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

Umgekehrter Zugriff

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

Ein IS zu viele viele Verbindungen (enthält die Tabelle Join).
Eg: Patient.hasMany('doctors', Doctor, { why: String }, { reverse: 'patients', key: true }).
. Der Patient jeden CAN - Arzt Ärzte haben viele können unterschiedliche Verschiedene Patienten haben viele.

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

Spaltenname Art
Patienten ID Integer (zusammengesetzter Schlüssel)
Arzt_ID Integer (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 ordnen Sie einem Patienten einen Arzt zu:

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

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

getAccessor

Dieser Accessor in diesem Assoziationstyp gibt ein zurück, ChainFindwenn kein Rückruf übergeben wird. Das bedeutet, dass Sie Folgendes tun können:

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. Jede Erweiterung befindet sich in einer neuen Tabelle, in der der eindeutige Bezeichner 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 });

Eine Tabelle erstellen Will die diese personmit Säulen idund name. Verlängerung der A Table schaffen person_addressmit Spalten person_id, streetund number. Erhältlich in den Verfahren der PersonModell ähnlich einem sind hasOne Association. Würden Sie das im diesem Beispiel zu Anruf der Lage sein .getAddress(cb), .setAddress(Address, cb)..

Hinweis: Sie müssen das Ergebnis von nicht 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 liegt an Ihnen. Wenn Sie nur darauf zugreifen möchten Mit dem Originalmodell können Sie die Rücksendung einfach verwerfen.

Examples & options

Wenn Sie eine Beziehung von 1 zu n haben, sollten Sie hasOne(gehört zu) Assoziation 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 (owner_id) verwenden möchten, 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 erfolgen, bevor die Zuordnung angegeben wird.

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, damit Assoziationen automatisch abgerufen werden, 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 anstelle einer pro Assoziationsbasis 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 zugeordnete Model senden. Wenn Sie beispielsweise eine Assoziation von ModelA zu ModelB haben, können Sie einen Accessor in ModelB 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 bei hasManyAssoziationen noch sinnvoller, da Sie die vielen zu vielen Assoziationen von beiden Seiten 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 DB-Transaktion 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; });

Externe Datenbankadapter hinzufügen

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

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

Sehen the documentation for creating adapters für mehr Details.