Objectrelationele mapping voor fibjs

Installeren

1
npm install fib-orm

Test

1
npm run ci

DBMS-ondersteuning

• MySQL en MariaDB
• SQLiet

Functies

fib-orm voegt een set synchrone versiemethoden toe aan het knooppunt-orm-object.

Invoering

Dit is een fibjs-object relationele mappingmodule.

Een voorbeeld:

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

De node.js-versie ziet er als volgt uit:

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

        });
    });
});

Documentatie

Fibjs heeft geen nieuwe functies toegevoegd, de ontwikkeling van documenten kan verwijzen naar node-orm, je hoeft alleen de asynchrone aanroep naar de synchrone versie te veranderen.wiki .

Instellingen

Zie informatie in de wiki .

Verbinden

Zie informatie in de wiki .

Modellen

Een model is een abstractie over een of meer databasetabellen. Modellen ondersteunen associaties (meer hieronder). Er wordt aangenomen dat de naam van het model overeenkomt met de tabelnaam.

Modellen ondersteunen gedrag voor het benaderen en manipuleren van tabelgegevens.

Modellen definiëren

Zie informatie in de wiki .

Properties

Zie informatie in de wiki .

Instance Methods

Worden doorgegeven tijdens de modeldefinitie.

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

Worden rechtstreeks op het model gedefinieerd.

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

Modellen laden [GEEN ONDERSTEUNING]

Modellen kunnen zich in afzonderlijke modules bevinden. Zorg er eenvoudigweg voor dat de module die de modellen bevat, module.exports gebruikt om een ​​functie te publiceren die de databaseverbinding accepteert, en laad vervolgens uw modellen zoals u dat wilt.

Let op: met deze techniek kunt u trapsgewijze belastingen realiseren.

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

Modellen synchroniseren

Zie informatie in de wiki .

Modellen laten vallen

Zie informatie in de wiki .

Geavanceerde mogelijkheden

Met ORM2 kunt u een aantal geavanceerde aanpassingen aan uw modeldefinities uitvoeren. U kunt deze configureren via de instellingen of in de aanroep naar definewanneer u het model instelt.

Elke Model-instantie heeft bijvoorbeeld een unieke ID in de database. Deze tabelkolom wordt automatisch toegevoegd en wordt standaard 'id' genoemd.
Als u uw eigen key: truekolom definieert, wordt 'id' niet toegevoegd:

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

Het huisdiermodel heeft 2 kolommen, een UIDen een name.

Het is ook mogelijk om samengestelde sleutels te hebben:

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

Andere opties:

• identityCache : (standaard: false) Stel dit in trueom identiteitscache in te schakelen ( Singletons ) of stel een time-outwaarde in (in seconden);
• autoSave : (standaard: false) Stel dit zo in dat trueeen exemplaar direct wordt opgeslagen nadat een eigenschap is gewijzigd;
• autoFetch : (standaard: false) Stel dit in trueom associaties op te halen bij het ophalen van een exemplaar uit de database;
• autoFetchLimit: (standaard: 1) Als autoFetchdit is ingeschakeld, definieert dit hoeveel borduurringen (associaties van associaties) u automatisch wilt ophalen.

Haken

Zie informatie in de wiki .

Voorwerpen vinden

Model.getSync(id, [ options ])

Om een ​​specifiek element uit de database te halen, gebruikt u Model.get.

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

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

Het vinden van een of meer elementen heeft meer opties, elk element kan in geen specifieke parametervolgorde worden opgegeven, maar optionshoeft alleen maar na te zijn conditions(zelfs als het een leeg object is).

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

Als u de resultaten moet sorteren omdat u ze beperkt of gewoon omdat u ze gesorteerd wilt hebben, doet u het volgende:

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)

Er zijn meer opties die je kunt doorgeven om iets te vinden. Deze opties worden doorgegeven in een tweede object:

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

U kunt bij het zoeken ook onbewerkte SQL gebruiken, zoals beschreven in het gedeelte Chaining hieronder.

Model.countSync([ conditions])

Als u alleen het aantal items wilt tellen dat aan een voorwaarde voldoet, kunt u dat gewoon gebruiken .count()in plaats van ze allemaal te vinden en te tellen. Dit zal de databaseserver feitelijk vertellen een telling uit te voeren (dit gebeurt niet in het knooppuntproces zelf). ).

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

Model.existsSync([ conditions])

Net als bij .count(), controleert deze methode alleen of het aantal groter is dan nul of niet.

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

Aggregating Functions

Er kunnen een Arrayaantal eigenschappen worden doorgegeven om slechts enkele eigenschappen te selecteren. Een Objectwordt ook geaccepteerd om voorwaarden te definiëren.

Hier is een voorbeeld om te illustreren hoe u het kunt gebruiken .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(): u kunt een getal als limiet doorgeven, of twee getallen als respectievelijk offset en limiet
• .order(): hetzelfde alsModel.find().order()

Aanvullende .aggregate()methoden

• min
• max
• avg
• sum
• count(er is een snelkoppeling naar dit - Model.count)

Er zijn meer aggregatiefuncties, afhankelijk van de bestuurder (bijvoorbeeld Wiskundige functies).

Chaining

Als u de voorkeur geeft aan een minder gecompliceerde syntaxis, kunt u een keten vormen .find()door geen callback-parameter op te geven.

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

Als u slechts één of twee eigenschappen wilt overslaan, kunt u bellen .omit()in plaats van .only.

Door ketenvorming zijn ingewikkeldere zoekopdrachten mogelijk. We kunnen bijvoorbeeld zoeken door aangepaste SQL op te geven:

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

Het is een slechte gewoonte om handmatig aan SQL-parameters te ontsnappen, omdat dit foutgevoelig is en uw applicatie wordt blootgesteld aan SQL-injectie. De ?syntaxis zorgt ervoor dat u kunt ontsnappen, door het vraagteken in de query veilig te vervangen door de opgegeven parameters. U kunt ook meerdere whereclausules aan elkaar koppelen nodig zijn.

.find, .where& .alldoen hetzelfde; ze zijn allemaal uitwisselbaar en aan elkaar te koppelen.

U kunt ook orderof 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( ... );

Je kunt ook ketenen en uiteindelijk gewoon de telling krijgen. In dit geval worden offset, limiet en volgorde genegeerd.

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

Ook beschikbaar is de optie om de geselecteerde items te verwijderen. Houd er rekening mee dat een geketende verwijdering geen haken oplevert.

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

U kunt ook wijzigingen aanbrengen in uw instances met behulp van de gebruikelijke Array-traversal-methoden en uiteindelijk alles opslaan.

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

Natuurlijk kun je dit direct op doen .find(), maar voor wat ingewikkelder taken kan dit erg handig zijn.

Model.find()retourneert geen array, dus je kunt niet zomaar direct een keten vormen. Om te beginnen met ketenen moet je bellen .each()(met een optionele callback als je de lijst wilt doorlopen). Je kunt dan de algemene functies gebruiken .filter(), .sort()en .forEach()meer dan eens.

Op het einde (of tijdens het proces..) kunt u bellen met:

• .countSync()als je gewoon wilt weten hoeveel items er zijn;
• .getSync()om de lijst op te halen;
• .saveSync()om alle itemwijzigingen op te slaan.

Voorwaarden

Voorwaarden worden gedefinieerd als een object waarbij elke sleutel een eigenschap is (tabelkolom). Alle sleutels moeten worden samengevoegd door de logische AND. Waarden worden geacht exact overeen te komen, tenzij u een . doorgeeft Array. In dit geval wordt er rekening mee gehouden een lijst om de woning mee te vergelijken.

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

Als je andere vergelijkingen nodig hebt, moet je een speciaal object gebruiken dat door een aantal helperfuncties is gemaakt. Hier zijn een paar voorbeelden om het te beschrijven:

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)

Ruwe zoekopdrachten

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

U kunt het identiteitspatroon gebruiken (standaard uitgeschakeld). Indien ingeschakeld, zullen meerdere verschillende zoekopdrachten resulteren in hetzelfde resultaat - u krijgt hetzelfde object. Als u andere systemen heeft die uw database kunnen wijzigen of als u een handleiding moet raadplegen Voor SQL-query's kunt u deze functie beter niet gebruiken. Het is ook bekend dat deze problemen kan veroorzaken bij complexe autofetch-relaties. Gebruik op eigen risico.

Het kan per model worden in-/uitgeschakeld:

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

en ook mondiaal:

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

De identiteitscache kan worden geconfigureerd om na een bepaalde tijd te verlopen door een getal door te geven in plaats van een Booleaanse waarde. Het getal wordt beschouwd als de time-out van de cache in seconden (je kunt drijvende komma gebruiken).

Opmerking : een uitzondering op caching is dat het niet wordt gebruikt als een exemplaar niet is opgeslagen. Als u bijvoorbeeld een persoon ophaalt en deze vervolgens wijzigt, wordt deze niet vanuit de cache doorgegeven terwijl deze niet wordt opgeslagen.

Artikelen maken

Model.createSync(items)

Om nieuwe elementen in de database in te voegen, gebruikt u 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

Artikelen bijwerken

Elk geretourneerd item heeft de eigenschappen die voor het model zijn gedefinieerd en ook een aantal methoden die u kunt gebruiken om elk item te wijzigen.

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

Het bijwerken en vervolgens opslaan van een exemplaar kan in één keer worden gedaan:

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

Als u een exemplaar wilt verwijderen, doet u het volgende:

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!");

Validaties

Zie informatie in de wiki .

Verenigingen

Een associatie is een relatie tussen een of meer tabellen.

hasOne

Is een veel-op-een- relatie. Het is hetzelfde als waartoe behoort.
Bijvoorbeeld: Animal.hasOne('owner', Person)Een
dier kan maar één eigenaar hebben, maar een persoon kan veel dieren hebben.
Aan dieren wordt de owner_ideigenschap automatisch toegevoegd.

De volgende functies komen beschikbaar:

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

Ketting zoeken

De hasOne-koppeling is ook compatibel met Chain Find. Met behulp van het bovenstaande voorbeeld kunnen we dit doen om toegang te krijgen tot een nieuw exemplaar van een ChainFind-object:

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

Omgekeerde toegang

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

zal het volgende toevoegen:

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

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

hasMany

Is een veel-op-veel- relatie (inclusief samenvoegingstabel).
Bijvoorbeeld: Patient.hasMany('doctors', Doctor, { why: String }, { reverse: 'patients', key: true })Patiënt
kan veel verschillende artsen hebben. Elke arts kan veel verschillende patiënten hebben.

Hierdoor wordt een join-tabel gemaakt patient_doctorswanneer u aanroept Patient.sync():

kolomnaam	type
patiënt_id	Geheel getal (samengestelde sleutel)
dokter_id	Geheel getal (samengestelde sleutel)
Waarom	Varchar(255)

De volgende functies zullen beschikbaar zijn:

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()

Om een ​​arts aan een patiënt te koppelen:

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

die wordt toegevoegd {patient_id: 4, doctor_id: 6, why: "remove appendix"}aan de jointabel.

krijgAccessor

Deze accessor in dit type associatie retourneert ChainFindeen callback als deze niet wordt doorgegeven. Dit betekent dat u dingen kunt doen als:

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

extendsTo

Als u optionele eigenschappen wilt opsplitsen in verschillende tabellen of verzamelingen, zal elke extensie in een nieuwe tabel staan, waarbij de unieke identificatie van elke rij de instantie-ID van het hoofdmodel is. Bijvoorbeeld:

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

Hiermee wordt een tabel gemaakt personmet kolommen iden name. De extensie maakt een tabel person_addressmet kolommen person_id, streeten number. De beschikbare methoden in het Personmodel zijn vergelijkbaar met een associatie. In dit voorbeeld zou u , , .. hasOne kunnen aanroepen..getAddress(cb).setAddress(Address, cb)

Opmerking: u hoeft het resultaat van niet op te slaan Person.extendsTo. Het retourneert een uitgebreid model. U kunt het gebruiken om rechtstreeks deze uitgebreide tabel te doorzoeken (en zelfs het gerelateerde model te vinden), maar dat is uw keuze. Als u er alleen toegang toe wilt hebben als u het originele model gebruikt, kunt u de retourzending gewoon weggooien.

Examples & options

Als je een relatie hebt van 1 tot n, gebruik dan hasOne(behoort tot) associatie.

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

U kunt het owner_idveld in de database als vereist markeren door de requiredoptie op te geven:

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

Als een veld niet verplicht is, maar gevalideerd moet worden, zelfs als het niet aanwezig is, specificeer dan de alwaysValidateoptie (dit kan bijvoorbeeld gebeuren als de validatie van een nulveld afhankelijk is van andere velden in het record).

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

Als u liever een andere naam voor het veld gebruikt (eigenaar_id), kunt u deze parameter in de instellingen wijzigen.

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

Opmerking: Dit moet worden gedaan voordat de koppeling wordt opgegeven.

De hasManyassociaties kunnen aanvullende eigenschappen hebben in de associatietabel.

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

Als u wilt, kunt u activeren autoFetch, zodat associaties automatisch worden opgehaald wanneer u exemplaren van een model ophaalt of vindt.

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

U kunt deze optie ook globaal definiëren in plaats van per associatie.

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

Associaties kunnen het gekoppelde model aanroepen met behulp van deze reverseoptie. Als u bijvoorbeeld een koppeling heeft van ModelA naar ModelB, kunt u een accessor in ModelB maken om instanties van ModelA op te halen. Verwarrend? Kijk eens naar het volgende voorbeeld.

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

Dit is zelfs nog logischer als je hasManyassociaties hebt, omdat je de vele tot vele associaties van beide kanten kunt beheren.

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(...);

Transactieondersteuning

U kunt de transactiefunctie op laag niveau gebruiken om db-transcatie te verwerken.

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

Of u kunt trans gebruiken om het eenvoudig te verwerken.

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

Externe databaseadapters toevoegen

Om een ​​externe databaseadapter toe te voegen aan orm, roept u de addAdaptermethode aan, waarbij u de alias doorgeeft die u wilt gebruiken om verbinding te maken met deze adapter, samen met de constructor voor de adapter:

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

Zienthe documentation for creating adaptersvoor meer details.