Fantastisches Community-Modul

Objektrelationale Zuordnung 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 eine Reihe synchroner Versionsmethoden für das Knoten-orm-Objekt hinzu.

Einführung

Dies ist ein relationales Zuordnungsmodul für fibjs-Objekte.

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 folgendermaßen 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, sondern muss nur den asynchronen Aufruf in eine synchrone Version ändern. Wiki .

die Einstellungen

Siehe Informationen im Wiki .

Anschließen

Siehe Informationen im Wiki .

Modelle

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

Modelle unterstützen Verhaltensweisen beim Zugriff auf und bei der Bearbeitung von Tabellendaten.

Modelle definieren

Siehe Informationen im Wiki .

Properties

Siehe Informationen im Wiki .

Instance Methods

Werden während 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

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

Modelle laden [NICHT UNTERSTÜTZEN]

Modelle können sich in separaten Modulen befinden. Stellen Sie einfach sicher, dass das Modul, in dem sich die Modelle befinden, module.exports verwendet, um eine Funktion zu veröffentlichen, die die Datenbankverbindung akzeptiert, und laden Sie dann Ihre Modelle, wie Sie möchten.

Wenn Sie diese Technik verwenden, 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 }); };

Modelle synchronisieren

Siehe Informationen im Wiki .

Modelle fallen lassen

Siehe Informationen im Wiki .

Erweiterte Optionen

Mit ORM2 können Sie einige erweiterte Änderungen an Ihren Modelldefinitionen vornehmen. Sie können diese über Einstellungen oder im Aufruf zum defineEinrichten des Modells konfigurieren .

Beispielsweise hat jede Modellinstanz eine eindeutige ID in der Datenbank. Diese Tabellenspalte wird automatisch hinzugefügt und standardmäßig als "ID" bezeichnet.
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 :) falseSets es trueIdentität Cache (ermöglichen Singletons ) oder einen Timeout - Wert (in Sekunden);
  • autoSave : (Standard :) falseSetzen Sie diese Option auf true, um eine Instanz direkt nach dem Ändern einer Eigenschaft zu speichern.
  • autoFetch : (Standard :) falseLegen Sie fest, dass truebeim Abrufen einer Instanz aus der Datenbank Assoziationen abgerufen werden sollen.
  • autoFetchLimit: (Standard :) 1Wenn autoFetchdiese Option aktiviert ist, wird festgelegt, 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 ])

Das Finden eines oder mehrerer Elemente verfügt über mehrere Optionen. Jedes Element kann in keiner bestimmten Parameterreihenfolge angegeben werden. Es optionsmuss nur nach conditions(auch wenn es sich um ein leeres Objekt handelt) erfolgen.

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 nur weil Sie möchten, dass sie sortiert werden, 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 Raw-SQL verwenden. Dies ist im Abschnitt Verkettung unten dokumentiert .

Model.countSync([ conditions])

Wenn Sie nur die Anzahl der Elemente zählen möchten, die einer Bedingung entsprechen, können Sie sie einfach verwenden, .count()anstatt alle zu finden und zu zählen. Dadurch wird der Datenbankserver tatsächlich angewiesen, 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 geprü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

Eine Arrayder Eigenschaften kann übergeben werden, um nur einige Eigenschaften auszuwählen. Eine Objectwird auch akzeptiert, um Bedingungen zu definieren.

Hier ist ein Beispiel zur Veranschaulichung .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(Es gibt eine Abkürzung dazu- Model.count)

Je nach Treiber gibt es mehr 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()stattdessen aufrufen .only.

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

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

Es ist eine schlechte Praxis, SQL-Parameter manuell zu maskieren, da sie fehleranfällig sind und Ihre Anwendung einer SQL-Injection aussetzen. Die ?Syntax sorgt dafür, dass Sie entkommen, indem Sie das Fragezeichen in der Abfrage sicher durch die angegebenen Parameter ersetzen. Sie können auch mehrere whereKlauseln als verketten erforderlich.

.find, .where& .alltun 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 abrufen. 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"

Ebenfalls verfügbar ist die Option zum Entfernen der ausgewählten Elemente. Beachten Sie, dass beim verketteten Entfernen keine Hooks ausgeführt werden.

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. [NOT SUPPORT]

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 tun .find(), aber für einige kompliziertere Aufgaben kann dies sehr nützlich sein.

Model.find()nicht einen Array zurück , so dass Sie nicht nur direkt Kette. So startet Verkettungs Sie anrufen .each()(mit einem optionalen Rückruf , wenn Sie die Liste zu durchqueren wollen). Anschließend können Sie 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 werden als ein Objekt definiert, bei dem jeder Schlüssel eine Eigenschaft ist (Tabellenspalte). Alle Schlüssel sollen durch die Logik verkettet werden AND. Werte werden als genau übereinstimmend angesehen, es sei denn, Sie übergeben eine Array. In diesem Fall wird dies berücksichtigt eine Liste, mit der die Immobilie verglichen werden kann.

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 einige Beispiele, um es 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)

Rohe Abfragen

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 diese Option aktiviert ist, führen mehrere verschiedene Abfragen zum gleichen Ergebnis. Sie erhalten dasselbe Objekt. Wenn Sie über andere Systeme verfügen, die Ihre Datenbank ändern können, oder wenn Sie ein Handbuch aufrufen müssen Bei SQL-Abfragen sollten Sie diese Funktion nicht verwenden. Es ist auch bekannt, dass sie Probleme mit komplexen automatischen Abrufbeziehungen verursacht. Die Verwendung erfolgt auf eigenes Risiko.

Es kann pro Modell aktiviert / deaktiviert werden:

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

und auch global:

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

Der Identitätscache kann so konfiguriert werden, dass er nach einer bestimmten Zeit abläuft, indem eine Zahl anstelle eines Booleschen Werts übergeben wird. Die Zahl wird als Cache-Zeitlimit 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 dann ändern, während sie nicht gespeichert wird, wird sie nicht aus dem Cache übergeben.

Elemente 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 Zuordnung 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 stehen zur Verfügung:

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-Zuordnung ist auch mit der Kettensuche kompatibel. Mit dem obigen Beispiel können wir auf diese Weise auf eine neue Instanz eines ChainFind-Objekts zugreifen:

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

Rückwärtszugriff

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

fügt Folgendes hinzu:

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 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 verbinden Sie einen Arzt mit einem Patienten:

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

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

getAccessor

Dieser Accessor in dieser Art von Zuordnung gibt einen ChainFindRückruf zurück, wenn er nicht weitergeleitet wird. Dies 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, 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 });

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 nicht speichern von 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 bei 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 die hasOneAssoziation verwenden (gehört zu).

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 folgende requiredOption angeben:

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

Wenn ein Feld nicht erforderlich ist, aber auch dann validiert werden soll, 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 zusätzliche Eigenschaften in der Assoziationstabelle 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 Zuordnungen 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 anstatt 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 });

Zuordnungen können mithilfe der reverseOption das zugeordnete Modell aufrufen. Wenn Sie beispielsweise eine Zuordnung von ModelA zu ModelB haben, können Sie in ModelB einen Accessor erstellen, um Instanzen von ModelA abzurufen. Verwirrend? Schauen 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 bis 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 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 die Verarbeitung zu vereinfachen.

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 ​​für die Verbindung mit diesem Adapter sowie den Konstruktor für den Adapter:

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

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