haro
1.0.0
HARO est un montant de données immuable moderne construit avec des fonctionnalités ES6. Il n'est pas opiné et propose une solution "plug-and-play" à la modélisation, à la recherche et à la gestion des données sur le client ou le serveur (en RAM). Il s'agit d'une structure de données partiellement persistante, en maintenant des ensembles de versions d'enregistrements dans versions (MVCC).
Toutes les méthodes sont synchrones.
Les index HARO ont la Map (field/property) > Map (value) > Set (PKs) qui permettent une recherche rapide et facile, ainsi qu'une inspection. Les index peuvent être gérés indépendamment des opérations del() et set() , par exemple, vous pouvez créer paresseusement de nouveaux index via reindex(field) , ou sortBy(field) .
Haro a une couverture de code à 100% avec ses tests.
----------|---------|----------|---------|---------|-------------------------------------------------------------------------------------------------------
File | % Stmts | % Branch | % Funcs | % Lines | Uncovered Line #s
----------|---------|----------|---------|---------|-------------------------------------------------------------------------------------------------------
All files | 100 | 83.56 | 100 | 100 |
haro.cjs | 100 | 83.56 | 100 | 100 | 49-75,108,163-175,192,224-228,242,264,266,274,308,326,353-354,359-361,375-378,380,437,475,482,486-496
----------|---------|----------|---------|---------|------------------------------------------------------------------------------------------------------- L'exportation nommée est haro , et la classe nommée exportée est Haro .
import { haro } from 'haro' ; const { haro } = require ( 'haro' ) ; Haro prend deux arguments facultatifs, le premier est un Array d'enregistrements pour définir de manière asynchrone, et le second est un descripteur de configuration.
const storeDefaults = haro ( ) ;
const storeRecords = haro ( [ { name : 'John Doe' , age : 30 } , { name : 'Jane Doe' , age : 28 } ] ) ;
const storeCustom = haro ( null , { key : 'id' } ) ; const store = haro ( null , { index : [ 'name' , 'age' ] } ) ,
data = [ { name : 'John Doe' , age : 30 } , { name : 'Jane Doe' , age : 28 } ] ;
const records = store . batch ( data , 'set' ) ;
console . log ( records [ 0 ] ) ; // [$uuid, {name: 'John Doe', age: 30}]
console . log ( store . size ) ; // 2
console . log ( store . find ( { age : 28 } ) ) ; // [[$uuid, {name: 'Jane Doe', age: 28}]]
console . log ( store . search ( / ^ja / i , 'name' ) ) ; // [[$uuid, {name: 'Jane Doe', age: 28}]]
console . log ( store . search ( arg => age < 30 , 'age' ) ) ; // [[$uuid, {name: 'Jane Doe', age: 28}]] const store = haro ( ) ;
let arg ;
arg = store . set ( null , { abc : true } ) ;
arg = store . set ( arg [ 0 ] , { abc : false } ) ;
arg = store . set ( arg [ 0 ] , { abc : true } ) ;
store . versions . get ( arg [ 0 ] ) . forEach ( i => console . log ( i [ 0 ] ) ) ; // {abc: true}, {abc: false} Une référence est incluse dans le référentiel et est utile pour évaluer la façon dont Haro fonctionnera sur différents matériels et logiciels.
time to batch insert data: 6.7825 ms
datastore record count: 1000
name indexes: 1000
testing time to 'find()' a record (first one is cold):
0.063375ms
0.004583ms
0.002417ms
0.003459ms
0.001916ms
testing time to 'search(regex, index)' for a record (first one is cold):
0.147792ms
0.051209ms
0.050958ms
0.051125ms
0.052166ms
time to override data: 0.361709 ms
testing time to 'search(regex, index)' on overridden data for a record (first one is cold):
0.053083ms
0.051916ms
0.027459ms
0.0275ms
0.032292ms
Fonction
Écouteur d'événements pour une opération par lots, reçoit type , data .
Fonction
Écouteur d'événements avant d'effacer le magasin de données.
Fonction
Écouteur d'événements pour avant qu'un enregistrement ne soit supprimé, reçoit key , batch .
Fonction
Écouteur d'événements pour avant qu'un enregistrement ne soit défini, reçoit data key .
Tableau
Tableau de valeurs à index. Les index composites sont pris en charge, en utilisant le délimiteur par défaut ( this.delimiter ). Les non-matchs dans les composites entraînent des valeurs vides.
Exemple de champs / propriétés à l'index:
const store = haro ( null , { index : [ 'field1' , 'field2' , 'field1|field2|field3' ] } ) ;Chaîne
Clé Object facultatif à utiliser en tant que touche Map , par défaut une version 4 UUID si elle n'est pas spécifiée ou trouvée.
Exemple de spécification de la clé primaire:
const store = haro ( null , { key : 'field' } ) ;Booléen
Logs des messages de stockage persistants à console , la valeur par défaut est true .
Fonction
Écouteur d'événements pour une opération par lots, reçoit deux arguments ['type', Array ].
Fonction
Écouteur d'événements pour effacer le magasin de données.
Fonction
Écouteur d'événements pour quand un enregistrement est supprimé, reçoit la clé d'enregistrement.
Fonction
Écouteur d'événements pour le moment où le magasin de données modifie l'ensemble de données, reçoit une String de nomment ce qui a changé ( indexes ou records ).
Fonction
Écouteur d'événements pour quand un enregistrement est défini, reçoit un Array .
Booléen
Activer / désactiver le versioning de style MVCC des enregistrements, la valeur par défaut est false . Les versions sont stockées dans Sets pour une itération facile.
Exemple d'activation du versioning:
const store = haro ( null , { versioning : true } ) ; Carte
Map des enregistrements, mise à jour par del() & set() .
Carte
Carte des index, qui sont des ensembles contenant des clés de carte.
Tableau
Array représentant l'ordre de this.data .
Nombre
Nombre d'enregistrements dans le centre de données.
Carte
Map des Sets d'enregistrements, mis à jour par set() .
Tableau
Le premier argument doit être un Array et le deuxième argument doit être del ou set .
const haro = require ( 'haro' ) ,
store = haro ( null , { key : 'id' , index : [ 'name' ] } ) ,
nth = 100 ,
data = [ ] ;
let i = - 1 ;
while ( ++ i < nth ) {
data . push ( { id : i , name : 'John Doe' + i } ) ;
}
// records is an Array of Arrays
const records = store . batch ( data , 'set' ) ;soi
Supprime toutes les paires de clés / valeur de la banque de données.
Exemple de compensation d'un bilan de données:
const store = haro ( ) ;
// Data is added
store . clear ( ) ;Indéfini
Supprime le record.
Exemple de supprimer un enregistrement:
const store = haro ( ) ,
rec = store . set ( null , { abc : true } ) ;
store . del ( rec [ 0 ] ) ;
console . log ( store . size ) ; // 0Tableau ou objet
Renvoie les enregistrements ou les index du tableau de données en tant que Array ou Object mutable, pour l'intention de réutiliser / stockage persistant sans s'appuyer sur un adaptateur qui briserait l'ensemble de données.
const store = haro ( ) ;
// Data is loaded
const records = store . dump ( ) ;
const indexes = store . dump ( 'indexes' ) ;
// Save records & indexesMapiterator
Renvoie un nouvel objet Iterator qui contient un tableau de [key, value] pour chaque élément de l'objet Map dans l'ordre d'insertion.
Exemple de supprimer un enregistrement:
const store = haro ( ) ;
let item , iterator ;
// Data is added
iterator = store . entries ( ) ;
item = iterator . next ( ) ;
do {
console . log ( item . value ) ;
item = iterator . next ( ) ;
} while ( ! item . done ) ;Tableau
Renvoie un Array de Arrays doubles avec la forme [key, value] pour les enregistrements qui a renvoyé true à callbackFn(value, key) .
Exemple de filtrage d'une banque de données:
const store = haro ( ) ;
// Data is added
store . filter ( function ( value ) {
return value . something === true ;
} ) ;Tableau
Renvoie un Array de Arrays doubles avec des valeurs indexées correspondant à l' where .
Exemple de recherche d'un (s) enregistrement (s) avec une correspondance d'identité:
const store = haro ( null , { index : [ 'field1' ] } ) ;
// Data is added
store . find ( { field1 : 'some value' } ) ;Indéfini
Appelle callbackFn une fois pour chaque paire de valeurs clés présente dans l'objet Map , dans l'ordre d'insertion. Si un paramètre thisArg est fourni à forEach , il sera utilisé comme valeur this valeur pour chaque rappel.
Exemple de supprimer un enregistrement:
const store = haro ( ) ;
store . set ( null , { abc : true } ) ;
store . forEach ( function ( value , key ) {
console . log ( key ) ;
} ) ;Tableau
Obtient l'enregistrement en tant que double Array avec la forme [key, value] .
Exemple d'obtention d'un enregistrement avec une valeur de clé primaire connue:
const store = haro ( ) ;
// Data is added
store . get ( 'keyValue' ) ;Booléen
Renvoie un Boolean indiquant si le magasin de données contient key .
Exemple de vérification d'un enregistrement avec une valeur de clé primaire connue:
const store = haro ( ) ;
// Data is added
store . has ( 'keyValue' ) ; // true or falseMapiterator
Renvoie un nouvel objet Iterator qui contient les touches pour chaque élément de l'objet Map dans l'ordre d'insertion.
Exemple d'obtention d'un itérateur et de journalisation des résultats:
const store = haro ( ) ;
let item , iterator ;
// Data is added
iterator = store . keys ( ) ;
item = iterator . next ( ) ;
do {
console . log ( item . value ) ;
item = iterator . next ( ) ;
} while ( ! item . done ) ;Tableau
Renvoie un Array de Arrays doubles avec la forme [key, value] pour la plage correspondante d'enregistrements.
Exemple de pagination d'un ensemble de données:
const store = haro ( ) ;
let ds1 , ds2 ;
// Data is added
console . log ( store . size ) ; // >10
ds1 = store . limit ( 0 , 10 ) ; // [0-9]
ds2 = store . limit ( 10 , 10 ) ; // [10-19]
console . log ( ds1 . length === ds2 . length ) ; // true
console . log ( JSON . stringify ( ds1 [ 0 ] [ 1 ] ) === JSON . stringify ( ds2 [ 0 ] [ 1 ] ) ) ; // falseTableau
Renvoie un Array des retours de callbackFn(value, key) . Si raw est true un Array est retourné.
Exemple de cartographie d'un centre de données:
const store = haro ( ) ;
// Data is added
store . map ( function ( value ) {
return value . property ;
} ) ;Booléen
Ceci est destiné à être utilisé dans un remplacement apparié des index et enregistrements, de sorte que vous pouvez éviter le chemin de code basé sur Promise d'un batch() insert ou load() . Accepte un troisième paramètre facultatif pour effectuer la transformation pour simplifier les problèmes de domaine croisé.
Exemple de remplacement d'une banque de données:
const store = haro ( ) ;
store . override ( { 'field' : { 'value' : [ 'pk' ] } } , "indexes" ) ;Tableau
Exécute un Array.reduce() inspiré de la fonction contre le magasin de données ( Map ).
Exemple de filtrage d'une banque de données:
const store = haro ( ) ;
// Data is added
store . reduce ( function ( accumulator , value , key ) {
accumulator [ key ] = value ;
return accumulator ;
} , { } ) ;Haro
Réindexonne le datastore, à appeler si vous modifiez la valeur de index .
Exemple de cartographie d'un centre de données:
const store = haro ( ) ;
// Data is added
// Creating a late index
store . reindex ( 'field3' ) ;
// Recreating indexes, this should only happen if the store is out of sync caused by developer code.
store . reindex ( ) ;Tableau
Renvoie un Array de Arrays doubles avec la forme [key, value] des enregistrements trouvés correspondant arg . Si arg est une Function (les paramètres sont value et index ), une correspondance est faite si le résultat est true , si arg est un RegExp la valeur de champ doit .test() comme true , sinon la valeur doit être une correspondance d'identité. Le paramètre index peut être une String ou Array de Strings ; Sinon, il est fourni par défaut à this.index .
Arrays indexés qui sont testés avec un RegExp seront traités comme une String délimitée par des virgules, par exemple ['hockey', 'football'] devient 'hockey, football' pour le RegExp .
Exemple de recherche avec une fonction de prédicat:
const store = haro ( null , { index : [ 'name' , 'age' ] } ) ,
data = [ { name : 'John Doe' , age : 30 } , { name : 'Jane Doe' , age : 28 } ] ;
store . batch ( data , 'set' )
console . log ( store . search ( function ( age ) {
return age < 30 ;
} , 'age' ) ) ; // [[$uuid, {name: 'Jane Doe', age: 28}]]Objet
Enregistrer dans le centre de données. Si key est false une version 4 UUID sera générée.
Si override est true , l'enregistrement existant sera remplacé au lieu de modifier.
Exemple de création d'un enregistrement:
const store = haro ( null , { key : 'id' } ) ,
record = store . set ( null , { id : 1 , name : 'John Doe' } ) ;
console . log ( record ) ; // [1, {id: 1, name: 'Jane Doe'}]Tableau
Renvoie un tableau de la banque de données, trié par callbackFn .
Exemple de tri comme un Array :
const store = haro ( null , { index : [ 'name' , 'age' ] } ) ,
data = [ { name : 'John Doe' , age : 30 } , { name : 'Jane Doe' , age : 28 } ] ;
store . batch ( data , 'set' )
console . log ( store . sort ( ( a , b ) => a < b ? - 1 : ( a > b ? 1 : 0 ) ) ) ; // [{name: 'Jane Doe', age: 28}, {name: 'John Doe', age: 30}]Tableau
Renvoie un Array de Arrays doubles avec la forme [key, value] des enregistrements triés par un index.
Exemple de tri par un index:
const store = haro ( null , { index : [ 'name' , 'age' ] } ) ,
data = [ { name : 'John Doe' , age : 30 } , { name : 'Jane Doe' , age : 28 } ] ;
store . batch ( data , 'set' )
console . log ( store . sortBy ( 'age' ) ) ; // [[$uuid, {name: 'Jane Doe', age: 28}], [$uuid, {name: 'John Doe', age: 30}]]Tableau
Renvoie un tableau de la banque de données.
Exemple de casting à un Array :
const store = haro ( ) ,
data = [ { name : 'John Doe' , age : 30 } , { name : 'Jane Doe' , age : 28 } ] ;
store . batch ( data , 'set' )
console . log ( store . toArray ( ) ) ; // [{name: 'John Doe', age: 30}, {name: 'Jane Doe', age: 28}]Mapiterator
Renvoie un nouvel objet Iterator qui contient les valeurs pour chaque élément de l'objet Map dans l'ordre d'insertion.
Exemple d'itération des valeurs:
const store = haro ( ) ,
data = [ { name : 'John Doe' , age : 30 } , { name : 'Jane Doe' , age : 28 } ] ;
store . batch ( data , 'set' )
const iterator = store . values ( ) ;
let item = iterator . next ( ) ;
while ( ! item . done ) {
console . log ( item . value ) ;
item = iterator . next ( ) ;
} ;Tableau
Idéal pour traiter un indice composite qui contient un Array de valeurs, ce qui rendrait la correspondance sur une seule valeur impossible lors de l'utilisation find() .
const store = haro ( null , { key : 'guid' , index : [ 'name' , 'name|age' , 'age' ] } ) ,
data = [ { guid : 'abc' , name : 'John Doe' , age : 30 } , { guid : 'def' , name : 'Jane Doe' , age : 28 } ] ;
store . batch ( data , 'set' ) ;
console . log ( store . where ( { name : 'John Doe' , age : 30 } ) ) ; // [{guid: 'abc', name: 'John Doe', age: 30}] Copyright (C) 2024 Jason Mulligan sous licence sous la licence BSD-3
