Mappage relationnel d'objets pour les fibjs

Installer

1
npm install fib-orm

Tester

1
npm run ci

Prise en charge du SGBD

• MySQL et MariaDB
• SQLite

Caractéristiques

fib-orm ajoute un ensemble de méthode de version synchrone sur l'objet node-orm.

introduction

Il s'agit d'un module de mappage relationnel d'objet fibjs.

Un exemple:

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

La version node.js comme ceci:

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

        });
    });
});

Documentation

Fibjs n'a pas ajouté de nouvelles fonctions, le développement de documents peut faire référence à node-orm, il suffit de changer l'appel asynchrone en version synchrone. Wiki .

Paramètres

Voir les informations dans le wiki .

De liaison

Voir les informations dans le wiki .

Des modèles

Un modèle est une abstraction sur une ou plusieurs tables de base de données. Les modèles prennent en charge les associations (voir ci-dessous). Le nom du modèle est supposé correspondre au nom de la table.

Les modèles prennent en charge les comportements d'accès et de manipulation des données de table.

Définition de modèles

Voir les informations dans le wiki .

Properties

Voir les informations dans le wiki .

Instance Methods

Sont transmis lors de la définition du modèle.

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

Sont définis directement sur le modèle.

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

Chargement de modèles [NOT SUPPORT]

Les modèles peuvent être dans des modules séparés. Assurez-vous simplement que le module contenant les modèles utilise module.exports pour publier une fonction qui accepte la connexion à la base de données, puis chargez vos modèles comme vous le souhaitez.

Remarque-en utilisant cette technique, vous pouvez avoir des charges en cascade.

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

Synchronisation des modèles

Voir les informations dans le wiki .

Suppression de modèles

Voir les informations dans le wiki .

Options avancées

ORM2 vous permet quelques ajustements avancés sur vos définitions de modèle. Vous pouvez les configurer via les paramètres ou dans l'appel pour define quand vous configurez le modèle.

Par exemple, chaque instance de modèle possède un ID unique dans la base de données. Cette colonne de table est ajoutée automatiquement et appelée "id" par défaut.
Si vous définissez votre propre colonne key: true , "id" ne sera pas ajouté:

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

Le modèle Pet aura 2 colonnes, un UID et un name .

Il est également possible d'avoir des clés composites:

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

Autres options:

• identityCache : (par défaut: false ) Réglez-le sur true pour activer le cache d'identité ( Singletons ) ou définissez une valeur de délai (en secondes);
• autoSave : (par défaut: false ) Réglez-le sur true pour enregistrer une instance juste après avoir modifié une propriété;
• autoFetch : (par défaut: false ) Réglez-le sur true pour récupérer les associations lors de l'extraction d'une instance de la base de données;
• autoFetchLimit : (par défaut: 1 ) Si autoFetch est activé, cela définit le nombre de cercles (associations d'associations) que vous voulez qu'il récupère automatiquement.

Crochets

Voir les informations dans le wiki .

Trouver des objets

Model.getSync(id, [ options ])

Pour obtenir un élément spécifique de la base de données, utilisez Model.get .

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

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

La recherche d'un ou de plusieurs éléments comporte plusieurs options, chacune d'entre elles pouvant être donnée sans ordre de paramètre spécifique. Seules les options doivent être après conditions (même s'il s'agit d'un objet vide).

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

Si vous avez besoin de trier les résultats parce que vous limitez ou simplement parce que vous voulez les trier, faites:

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)

Il existe d'autres options que vous pouvez passer pour trouver quelque chose. Ces options sont transmises dans un deuxième objet:

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

Vous pouvez également utiliser du SQL brut lors de la recherche. Il est documenté dans la section Chaînage ci-dessous.

Model.countSync([ conditions])

Si vous voulez simplement compter le nombre d'éléments qui correspondent à une condition, vous pouvez simplement utiliser .count() au lieu de tous les trouver et de compter. Cela indiquera en fait au serveur de base de données de faire un comptage (ce ne sera pas fait dans le processus de nœud lui-même).

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

Model.existsSync([ conditions])

Similaire à .count() , cette méthode vérifie simplement si le nombre est supérieur à zéro ou non.

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

Aggregating Functions

Un Array de propriétés peut être transmis pour sélectionner seulement quelques propriétés. Un Object est également accepté pour définir les conditions.

Voici un exemple pour illustrer comment utiliser .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() base .aggregate()

• .limit() : vous pouvez passer un nombre comme limite, ou deux nombres comme offset et limite respectivement
• .order() : identique à Model.find().order()

.aggregate() supplémentaires .aggregate()

• min
• max
• avg
• sum
• count (il y a un raccourci vers this- Model.count )

Il existe plus de fonctions d'agrégation selon le pilote (fonctions mathématiques par exemple).

Chaining

Si vous préférez une syntaxe moins compliquée, vous pouvez chaîner .find() en ne donnant pas de paramètre de rappel.

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

Si vous ne souhaitez ignorer qu'une ou deux propriétés, vous pouvez appeler .omit() au lieu de .only .

Le chaînage permet des requêtes plus complexes. Par exemple, nous pouvons effectuer une recherche en spécifiant du SQL personnalisé:

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

Il est déconseillé d'échapper manuellement aux paramètres SQL car il est sujet aux erreurs et expose votre application à l'injection SQL. La syntaxe ? Se charge de s'échapper pour vous, en remplaçant en toute sécurité le point d'interrogation dans la requête par les paramètres fournis. Vous pouvez également chaîner plusieurs where clauses au besoin.

.find , .where & .all faire la même chose; tous sont interchangeables et chaînables.

Vous pouvez également order ou 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( ... );

Vous pouvez également enchaîner et obtenir simplement le décompte à la fin. Dans ce cas, le décalage, la limite et l'ordre sont ignorés.

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

L'option permettant de supprimer les éléments sélectionnés est également disponible. Notez qu'une suppression chaînée n'exécutera aucun hook.

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

Vous pouvez également apporter des modifications à vos instances à l'aide des méthodes courantes de traversée de tableaux et tout enregistrer à la fin. [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
});

Bien sûr, vous pouvez le faire directement sur .find() , mais pour certaines tâches plus compliquées, cela peut être très utile.

Model.find() ne renvoie pas de tableau, vous ne pouvez donc pas simplement enchaîner directement. Pour commencer le chaînage, vous devez appeler .each() (avec un rappel facultatif si vous souhaitez parcourir la liste). Vous pouvez ensuite utiliser la fonction commune fonctions .filter() , .sort() et .forEach() plusieurs fois.

À la fin (ou pendant le processus ..) vous pouvez appeler:

• .countSync() si vous voulez juste savoir combien il y a d'éléments;
• .getSync() pour récupérer la liste;
• .saveSync() pour enregistrer toutes les modifications des éléments.

Conditions

Les conditions sont définies comme un objet où chaque clé est une propriété (colonne de table). Toutes les clés sont censées être concaténées par le AND logique. Les valeurs sont considérées comme correspondant exactement, sauf si vous transmettez un Array . Dans ce cas, il est pris en compte une liste avec laquelle comparer la propriété.

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

Si vous avez besoin d'autres comparaisons, vous devez utiliser un objet spécial créé par certaines fonctions d'assistance. Voici quelques exemples pour le décrire:

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)

Requêtes brutes

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

Vous pouvez utiliser le modèle d'identité (désactivé par défaut). S'il est activé, plusieurs requêtes différentes aboutiront au même résultat - vous obtiendrez le même objet. Si vous disposez d'autres systèmes qui peuvent modifier votre base de données ou si vous devez appeler un manuel Requêtes SQL, vous ne devez pas utiliser cette fonctionnalité. Elle est également connue pour causer des problèmes avec des relations complexes de lecture automatique. Utilisez à vos risques et périls.

Il peut être activé / désactivé par modèle:

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

et aussi globalement:

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

Le cache d'identité peut être configuré pour expirer après un certain temps en transmettant un nombre au lieu d'un booléen. Le nombre sera considéré comme le délai d'expiration du cache en secondes (vous pouvez utiliser une virgule flottante).

Remarque : une exception concernant la mise en cache est qu'elle ne sera pas utilisée si une instance n'est pas enregistrée. Par exemple, si vous récupérez une personne, puis la modifiez, elle ne sera pas transmise du cache tant qu'elle n'est pas enregistrée.

Créer des éléments

Model.createSync(items)

Pour insérer de nouveaux éléments dans la base de données, utilisez 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

Mettre à jour des éléments

Chaque élément retourné possède les propriétés définies pour le modèle et également quelques méthodes que vous pouvez utiliser pour modifier chaque élément.

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

La mise à jour puis l'enregistrement d'une instance peuvent être effectués en un seul appel:

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

Si vous souhaitez supprimer une instance, faites simplement:

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

Validations

Voir les informations dans le wiki .

Les associations

Une association est une relation entre une ou plusieurs tables.

hasOne

Est une relation plusieurs à un . C'est la même que celle à laquelle appartient.
Par exemple: Animal.hasOne('owner', Person) .
L'animal ne peut avoir qu'un seul propriétaire, mais la personne peut avoir plusieurs animaux.
L'animal aura la propriété owner_id ajoutée automatiquement.

Les fonctions suivantes seront disponibles:

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

Recherche de chaîne

L'association hasOne est également compatible avec la recherche de chaîne. En utilisant l'exemple ci-dessus, nous pouvons le faire pour accéder à une nouvelle instance d'un objet ChainFind:

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

Accès inversé

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

ajoutera ce qui suit:

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

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

hasMany

Est une relation plusieurs à plusieurs (inclut la table de jointure).
Par exemple: Patient.hasMany('doctors', Doctor, { why: String }, { reverse: 'patients', key: true }) .
Le patient peut avoir plusieurs médecins différents, et chaque médecin peut avoir plusieurs patients différents.

Cela créera une table de patient_doctors lorsque vous appelez Patient.sync() :

Les fonctions suivantes seront disponibles:

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

Pour associer un médecin à un patient:

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

qui ajoutera {patient_id: 4, doctor_id: 6, why: "remove appendix"} à la table de jointure.

getAccessor

Cet accesseur dans ce type d'association renvoie un ChainFind s'il ne transmet pas de rappel. Cela signifie que vous pouvez faire des choses comme:

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

extendsTo

Si vous souhaitez diviser les propriétés facultatives en différentes tables ou collections. Chaque extension sera dans une nouvelle table, où l'identificateur unique de chaque ligne est l'ID de l'instance du modèle principal. Par exemple:

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

Cela créera une table person avec les colonnes id et name . L'extension créera une table person_address avec les colonnes person_id , street et number . Les méthodes disponibles dans le modèle Person sont similaires à une association hasOne . Dans cet exemple, vous pourrez appeler .getAddress(cb) , .setAddress(Address, cb) , ..

Remarque: vous n'avez pas besoin d'enregistrer le résultat de Person.extendsTo . Il renvoie un modèle étendu. Vous pouvez l'utiliser pour interroger directement cette table étendue (et même trouver le modèle associé), mais c'est à vous de Person.extendsTo . Si vous le souhaitez uniquement pour y accéder en utilisant le modèle d'origine, vous pouvez simplement supprimer le retour.

Examples & options

Si vous avez une relation de 1 à n, vous devez utiliser l'association hasOne (appartient à).

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

Vous pouvez marquer le champ owner_id comme requis dans la base de données en spécifiant l'option required :

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

Si un champ n'est pas obligatoire, mais doit être validé même s'il n'est pas présent, spécifiez l'option alwaysValidate (cela peut se produire, par exemple lorsque la validation d'un champ nul dépend d'autres champs de l'enregistrement)

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

Si vous préférez utiliser un autre nom pour le champ (owner_id), vous pouvez modifier ce paramètre dans les paramètres.

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

Remarque: Cela doit être fait avant que l'association ne soit spécifiée.

Les associations hasMany peuvent avoir des propriétés supplémentaires dans la table d'association.

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

Si vous préférez, vous pouvez activer la autoFetch . De cette façon, les associations sont automatiquement récupérées lorsque vous obtenez ou trouvez des instances d'un modèle.

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

Vous pouvez également définir cette option globalement au lieu d'une base par association.

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

Les associations peuvent appeler le modèle associé à l'aide de l'option reverse . Par exemple, si vous avez une association de ModelA à ModelB, vous pouvez créer un accesseur dans ModelB pour obtenir des instances de ModelA. Confus? Regardez l'exemple suivant.

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

Cela a encore plus de sens lorsque vous hasMany associations hasMany puisque vous pouvez gérer les associations plusieurs à plusieurs des deux côtés.

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

Prise en charge des transactions

Vous pouvez utiliser la fonction de transaction de bas niveau pour traiter la conversion de base de données.

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

Ou vous pouvez utiliser trans pour simuler le traitement.

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

Ajout d'adaptateurs de base de données externes

Pour ajouter un adaptateur de base de données externe à orm , appelez la méthode addAdapter , en transmettant l'alias à utiliser pour la connexion à cet adaptateur, avec le constructeur de l'adaptateur:

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

Consultez the documentation for creating adapters pour plus de détails.