Fantastisches Community-Modul

Objektrelationale Zuordnung für Fibjs

Build-Status

Installieren

1
npm install fib-orm

Test

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 .

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.

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

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 konfigurieren, um zu define wann Sie das Modell einrichten.

Beispielsweise hat jede Modellinstanz eine eindeutige ID in der Datenbank. Diese Tabellenspalte wird automatisch hinzugefügt und standardmäßig als "ID" bezeichnet.
Wenn Sie Ihren eigenen key: true definieren key: true Spalte, 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 UID und einen 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 } });

Weitere Optionen:

  • identityCache : (Standard: false ) Setzen Sie diesen Wert auf true , um den Identitätscache ( Singletons ) zu aktivieren, oder legen Sie einen Zeitlimitwert (in Sekunden) fest.
  • autoSave : (Standard: false ) Setzen Sie diesen autoSave auf true , um eine Instanz direkt nach dem Ändern einer Eigenschaft zu speichern.
  • autoFetch : (Standard: false ) Setzen Sie diesen autoFetch auf true , um beim Abrufen einer Instanz aus der Datenbank Zuordnungen abzurufen.
  • autoFetchLimit : (Standard: 1 ) Wenn autoFetch aktiviert ist, wird definiert, wie viele Rahmen (Assoziationen von Assoziationen) automatisch abgerufen werden sollen.

Haken

Siehe Informationen im Wiki .

Gegenstände finden

Model.getSync(id, [ options ])

Verwenden Sie Model.get um ein bestimmtes Element aus der Datenbank 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. Nur options müssen nach 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 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 einfach .count() anstatt alle zu finden und zu zählen. Dadurch wird der Datenbankserver tatsächlich .count() , eine Zählung .count() (dies wird nicht durchgeführt) der 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 nur, 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 Array von Eigenschaften kann übergeben werden, um nur einige Eigenschaften auszuwählen. Ein Object wird auch zum Definieren von Bedingungen akzeptiert.

Hier ist ein Beispiel zur Veranschaulichung der Verwendung von .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'

Basis .aggregate() Methoden

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

Zusätzliche .aggregate() -Methoden

  • min
  • max
  • avg
  • sum
  • count (es gibt eine Verknüpfung zu this- Model.count )

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

Chaining

Wenn Sie eine weniger komplizierte Syntax bevorzugen, können Sie .find() indem Sie keinen .find() .

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 .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-Injektion 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 where verketten Klauseln nach Bedarf.

.find , .where & .all tun Thing The Same, alles , was sie sind austauschbar und verkettbar.

Sie können auch order oder 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 mithilfe gängiger 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 auf .find() tun, 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 .each() aufrufen (mit einem optionalen Rückruf, wenn Sie die Liste durchlaufen möchten). Sie können dann das Common verwenden Funktionen .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 Elemente vorhanden sind;
  • .getSync() , um die Liste abzurufen;
  • .saveSync() , um alle .saveSync() zu speichern.

Bedingungen

Bedingungen werden als ein Objekt definiert, bei dem jeder Schlüssel eine Eigenschaft ist (Tabellenspalte). Alle Schlüssel sollen durch das logische AND verkettet werden. Die Werte stimmen genau überein, es sei denn, Sie übergeben ein 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 unterschiedliche 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 Bei SQL-Abfragen sollten Sie diese Funktion nicht verwenden. Es ist auch bekannt, dass bei komplexen automatischen Abrufbeziehungen Probleme auftreten. 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)

Verwenden Sie Model.create um neue Elemente in die Datenbank 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

Ist eine Viele-zu-Eins- Beziehung. Es ist das gleiche wie zu gehört.
ZB: Animal.hasOne('owner', Person) .
Tier kann nur einen Besitzer haben, aber Person kann viele Tiere haben.
Bei Animal wird die Eigenschaft owner_id 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 Kettenfindung 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

Ist eine Viele-zu-Viele- Beziehung (einschließlich Join-Tabelle).
Beispiel: Patient.hasMany('doctors', Doctor, { why: String }, { reverse: 'patients', key: true }) : 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 patient_doctors wenn Sie Patient.sync() aufrufen:

Spaltenname Typ
patient_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"})

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

getAccessor

Dieser Accessor in dieser Art von Zuordnung gibt einen ChainFind wenn kein Rückruf übergeben wird. Dies bedeutet, dass Sie ChainFind 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 });

Das dies von Will Create A die Tabelle person mit den Spalten id und name . Bei der Erweiterung von Will A das Erstellen der Tabelle person_address mit den Säulen person_id , street und number . Zu den Methoden des erhältlich bei The Person Modell sind ähnlich eine hasOne Vereinigung oder. Einer Im diesem Beispiel Möchten Sie von der Lage zu Anrufen .getAddress(cb) , .setAddress(Address, cb) , ..

Hinweis: Sie müssen das Ergebnis nicht aus 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 möchten Um mit dem Originalmodell darauf zuzugreifen, können Sie die Rücksendung einfach verwerfen.

Examples & options

Wenn Sie eine Beziehung von 1 zu n haben, sollten Sie die hasOne (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 Feld owner_id als in der Datenbank erforderlich markieren, indem Sie die required Option owner_id :

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 Option alwaysValidate . (Dies kann beispielsweise passieren, wenn die Validierung eines alwaysValidate von anderen Feldern im Datensatz abhängt.)

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

Wenn Sie einen anderen Namen für das Feld (owner_id) bevorzugen, 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 hasMany Zuordnungen können zusätzliche Eigenschaften in der Zuordnungstabelle 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 autoFetch aktivieren. Auf diese Weise werden Zuordnungen automatisch abgerufen, wenn Sie Instanzen eines Modells autoFetch 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 das zugeordnete Modell mithilfe der reverse Option 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

Bildet den Sinn , wenn die selbst die dies die HAVING hasMany Verbände Tätig seit Sie das können an der viele viele Verbände verwalten von beiden-Sides.

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 zu orm , rufen Sie die Methode addAdapter 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);

Weitere Informationen finden Sie in the documentation for creating adapters .