Mappage relationnel objet pour fibjs

Installer

1
npm install fib-orm

Test

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éfinir des 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 [PAS DE 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 bon vous semble.

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 .

Abandon des 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 à definelorsque vous configurez le modèle.

Par exemple, chaque instance de modèle a un identifiant 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 key: truecolonne, "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 pour animaux de compagnie aura 2 colonnes, une UIDet une 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 :) falseDéfinissez-le sur truepour activer le cache d'identité ( Singletons ) ou définissez une valeur de délai d'attente (en secondes);
• autoSave : (par défaut :) falseDéfinissez-le sur truepour enregistrer une instance juste après avoir modifié une propriété ;
• autoFetch : (par défaut :) falseDéfinissez-le sur truepour récupérer les associations lors de la récupération d'une instance à partir de la base de données ;
• autoFetchLimit: (par défaut :) 1Si autoFetchest 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 ])

Trouver un ou plusieurs éléments a plus d'options, chacun peut être donné dans aucun ordre de paramètre spécifique. Seulement optionsaprè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 devez trier les résultats parce que vous limitez ou simplement parce que vous voulez qu'ils soient triés, procédez comme suit :

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 transmettre 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. C'est documenté dans la section Chaînage ci-dessous.

Model.countSync([ conditions])

Si vous voulez juste compter le nombre d'éléments qui correspondent à une condition, vous pouvez simplement utiliser .count()au lieu de tous les trouver et de les compter. Cela indiquera en fait au serveur de base de données de faire un compte (cela 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])

Semblable à .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 Arraydes propriétés peut être passé pour ne sélectionner que quelques propriétés. Un Objectest également accepté pour définir des 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()Méthodes de base

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

.aggregate()Méthodes supplémentaires

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

Il y a plus de fonctions agrégées selon le pilote (fonctions mathématiques par exemple).

Chaining

Si vous préférez une syntaxe moins compliquée, vous pouvez enchaî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 souhaitez ignorer une ou deux propriétés, vous pouvez appeler .omit()au lieu de .only.

Le chaînage permet des requêtes plus compliquées. Par exemple, nous pouvons rechercher 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 cela est sujet aux erreurs et expose votre application à l'injection SQL. La ?syntaxe s'occupe de l'échappement 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 enchaîner plusieurs whereclauses comme nécessaire.

.find, .where& .allfont la même chose ; ils sont tous interchangeables et chaînés.

Vous pouvez également orderou 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 le décompte à la fin. Dans ce cas, l'offset, 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 de suppression des éléments sélectionnés est également disponible. Notez qu'une suppression enchaî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 de méthodes courantes de traversée de tableau et tout enregistrer à la fin.

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 un tableau, vous ne pouvez donc pas simplement chaî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 les fonctions courantes .filter(), .sort()et .forEach()plus d'une fois.

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

• .countSync() si vous voulez juste savoir combien il y a d'articles ;
• .getSync() pour récupérer la liste ;
• .saveSync() pour enregistrer toutes les modifications apportées aux é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 logique AND. Les valeurs sont considérées comme correspondant exactement, à moins que vous ne passiez un Array. Dans ce cas, il est considéré une liste pour comparer la propriété avec.

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 donneront le même résultat - vous obtiendrez le même objet. Si vous avez d'autres systèmes qui peuvent modifier votre base de données ou si vous devez appeler un manuel Requêtes SQL, vous ne devriez pas utiliser cette fonctionnalité. Elle est également connue pour causer des problèmes avec les relations d'autorécupération complexes. 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 une période de temps en passant 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 la virgule flottante).

Remarque : Une exception à propos de 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 à partir du cache tant qu'elle n'est pas enregistrée.

Création d'articles

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

Mise à jour des éléments

Chaque élément renvoyé possède les propriétés qui ont été définies pour le modèle ainsi que 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 se faire 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!");

Validation

Voir les informations dans le wiki .

Les associations

Une association est une relation entre une ou plusieurs tables.

hasOne

A EST NOMBREUX à Un . C'est une relation au même, AS appartient à.
Par exemple : Animal.hasOne('owner', Person).
. L'animal PEUT avoir qu'un seul propriétaire, avoir BEAUCOUP PEUT mais la personne Animals
Animal par aura à la owner_idpropriété Ajouté 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

A IS many to many Relation (y compris la table de jointure).
Par exemple , de: Patient.hasMany('doctors', Doctor, { why: String }, { reverse: 'patients', key: true }).
. Le patient Chaque Médecins CAN docteur ont ont peut de nombreux patients différents ont ont de nombreux.

Cela créera une table de jointure patient_doctorslorsque vous appelezPatient.sync() :

nom de colonne	taper
id_patient	Entier (clé composite)
doctor_id	Entier (clé composite)
Pourquoi	varchar (255)

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 s'ajoutera {patient_id: 4, doctor_id: 6, why: "remove appendix"}à la table de jointure.

getAccessor

Cet accesseur dans ce type d'association renvoie un ChainFinds'il ne passe pas un 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 peut-être des propriétés facultatives en différentes tables ou collections. Chaque extension sera dans une nouvelle table, où l'identifiant unique de chaque ligne est l'ID d'instance de 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
});

A Create Table Will the this personwith Columns idand name. Extension of The Will Create A Table person_addresswith Columns person_id, streetet number. Disponible dans Les méthodes du Personmodèle Similaires à AN sont hasOne Association. Dans cet exemple ÊTES-vous capable d'appeler .getAddress(cb), .setAddress(Address, cb), ..

Remarque : vous n'avez pas besoin d'enregistrer le résultat à partir 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 décider. Si vous souhaitez uniquement y accéder en utilisant le modèle d'origine, vous pouvez simplement jeter le retour.

Examples & options

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

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 owner_idchamp comme requis dans la base de données en spécifiant l' requiredoption :

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, alors spécifiez l' alwaysValidateoption. (cela peut arriver, 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 : Cette opération doit être effectuée avant que l'association ne soit spécifiée.

Les hasManyassociations 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 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 faire des appels au modèle associé à l'aide de l' reverseoption. Par exemple, si vous avez une association de ModelA vers ModelB, vous pouvez créer un accesseur dans ModelB pour obtenir des instances de ModelA. Une confusion ? 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 hasManyvous avez des associations, car vous pouvez gérer plusieurs à plusieurs associations 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 transcation 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 simplifier 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 addAdapterméthode, en passant l'alias à utiliser pour la connexion à cet adaptateur, ainsi que le constructeur de l'adaptateur :

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

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