Mappage relationnel d'objets pour les fibjs
Installer
1npm install fib-orm
Tester
1npm run ci
Prise en charge du SGBD
- MySQL et MariaDB
- SQLite
traits
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
37var 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
49var 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 .
Réglages
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
13var 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
9var 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
12var 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
4var Person = db.define("person", {
firstname : { type: 'text', key: true },
lastname : { type: 'text', key: true }
});
Autres options:
-
identityCache
: (par défaut:false
) Réglez-le surtrue
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 surtrue
pour enregistrer une instance juste après avoir modifié une propriété; -
autoFetch
: (par défaut:false
) Réglez-le surtrue
pour récupérer les associations lors de l'extraction d'une instance de la base de données; -
autoFetchLimit
: (par défaut:1
) SiautoFetch
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
2var 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
2var 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, faites:
1
2
3
4
5
6var 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
2var 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 (cela ne sera pas fait dans le processus de nœud lui-même).
1
2var 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
2var 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 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()
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
3var 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é:
1Person.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
3Person.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
2var 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
2Person.find({ surname: "Doe" }).removeSync();
// Does gone..
Vous pouvez également apporter des modifications à vos instances à l'aide des méthodes courantes de traversée des tableaux et tout enregistrer à la fin. [NOT SUPPORT]
1
2
3
4
5
6
7
8
9
10
11
12
13Person.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 des 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
13var 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 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 propres risques.
Il peut être activé / désactivé par modèle:
1
2
3
4
5var Person = db.define('person', {
name : String
}, {
identityCache : true
});
et aussi globalement:
1
2var db = orm.connectSync('...');
db.settings.set('instance.identityCache', true);
Le cache d'identité peut être configuré pour expirer après un certain 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 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
15var 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 dans le modèle et également quelques méthodes que vous pouvez utiliser pour modifier chaque élément.
1
2
3
4
5var 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
3var 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
4animal.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:
1Animal.findByOwner({ /* options */ })
Accès inversé
1Animal.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()
:
nom de colonne | type |
---|---|
patient_id | 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
12patient.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:
1patient.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 passe pas de rappel. Cela signifie que vous pouvez faire des choses comme:
1
2var 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
7var 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'ê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 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
13var 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
:
1Animal.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)
1Animal.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.
1db.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
11var 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
12var 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
10var 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. Vous ne savez pas? Regardez l'exemple suivant.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16var 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
15var 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
6db.begin();
...
if(err)
db.rollback();
else
db.commit();
Ou vous pouvez utiliser trans pour simuler le traitement.
1
2
3
4var 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 avec cet adaptateur, avec le constructeur de l'adaptateur:
1require('orm').addAdapter('cassandra', CassandraAdapter);
Consultez the documentation for creating adapters pour plus de détails.