Mappage relationnel d'objets 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éthodes de version synchrone sur l'objet node-orm.

Introduction

Il s'agit d'un module de mappage relationnel d'objets 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 (plus d'informations 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 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 lors de l'appel definelorsque 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 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 Pet aura 2 colonnes, an UIDet a 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) Définissez-le truepour activer le cache d'identité ( Singletons ) ou définissez une valeur de délai d'attente (en secondes) ;
• autoSave : (par défaut :false ) Définissez-le pour trueenregistrer une instance juste après avoir modifié une propriété ;
• autoFetch : (par défaut : false) Définissez-le truepour récupérer les associations lors de la récupération d'une instance de la base de données ;
• autoFetchLimit: (par défaut : 1) Si autoFetchest activé, cela définit le nombre de cercles (associations d'associations) que vous souhaitez 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é sans ordre de paramètre spécifique. Il suffit optionsd'ê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 devez trier les résultats parce que vous limitez ou simplement parce que vous souhaitez 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 souhaitez simplement compter le nombre d'éléments qui correspondent à une condition, vous pouvez simplement les 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 dé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 Arraynombre de propriétés peut être transmis pour sélectionner seulement 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 décalage et limite respectivement
• .order(): pareil queModel.find().order()

.aggregate()Méthodes supplémentaires

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

Il existe davantage de fonctions agrégées selon le driver (fonctions Math 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 seulement une ou deux propriétés, vous pouvez appeler .omit()à la place 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 cela est sujet aux erreurs et expose votre application à une injection SQL. La ?syntaxe se charge 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înables.

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 simplement obtenir 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 en chaîne 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 parcours de tableaux 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 s'avérer très utile.

Model.find()ne renvoie pas de 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 communes .filter(), .sort()et .forEach()plus d'une fois.

En fin de compte (ou pendant le processus..), vous pouvez appeler :

• .countSync()si vous voulez juste savoir combien d’articles il y a ;
• .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 du tableau). Toutes les clés sont censées être concaténées par le . logique AND. Les valeurs sont considérées comme correspondant exactement, sauf si vous transmettez un Array. Dans ce cas, il est considéré 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). Si 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 devez pas utiliser cette fonctionnalité. Elle est également connue pour causer des problèmes avec des relations de récupération automatique complexes. Utilisez-la à vos propres risques.

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 à l'échelle mondiale :

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 à 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, tant qu'elle n'est pas enregistrée, elle ne sera pas transmise du cache.

Création d'é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

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

Validations

Voir les informations dans le wiki .

Les associations

Une association est une relation entre une ou plusieurs tables.

hasOne

Il s'agit d'une relation plusieurs à un . C'est la même chose que appartient à.
Par exemple : Animal.hasOne('owner', Person).
L'animal ne peut avoir qu'un seul propriétaire, mais la personne peut avoir plusieurs animaux.
La propriété de l'animal sera owner_idautomatiquement ajoutée.

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 faire cela 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

Il s'agit d'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. Chaque médecin peut avoir plusieurs patients différents.

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

nom de colonne	taper
id_patient	Entier (clé composée)
doctor_id	Entier (clé composée)
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 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 des propriétés peut-être facultatives en différentes tables ou collections. Chaque extension sera dans une nouvelle table, où l'identifiant unique de chaque ligne est l'ID de l'instance principale du modèle. 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 personavec des colonnes idet name. L'extension créera une table person_addressavec des colonnes person_id, streetet number. Les méthodes disponibles dans le Personmodèle sont similaires à une hasOne association. Dans cet exemple, vous pourrez appeler .getAddress(cb), .setAddress(Address, cb), ..

Remarque : vous n'êtes pas obligé 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 cela dépend de vous. Si vous souhaitez uniquement y accéder en utilisant le modèle original, vous pouvez simplement supprimer le retour.

Examples & options

Si vous avez une relation de 1 à n, vous devez utiliser hasOnel'association (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 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 précisez 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 : Cela doit être effectué avant que l'association ne soit spécifiée.

Les hasManyassociations peuvent avoir des propriétés supplémentaires dans la table des associations.

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 plutôt que 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' reverseoption. Par exemple, si vous avez une association de ModelA à ModelB, vous pouvez créer un accesseur dans ModelB pour obtenir des instances de ModelA. Cela vous semble 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 est encore plus logique lorsqu'il s'agit hasManyd'associations puisque vous pouvez gérer de nombreuses 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 transaction 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 le traiter simplement.

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 transmettant l'alias à utiliser pour se connecter à cet adaptateur, ainsi que le constructeur de l'adaptateur :

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

Voirthe documentation for creating adapterspour plus de détails.