EWD 3 Training Course Part 19: The cache.node APIs

Copyright © 2016 M/Gateway Developments Ltd
EWD 3 Training Course
Part 19
Accessing a Global Storage
Database from JavaScript: the
cache.node APIs
Rob Tweed
Director, M/Gateway Developments Ltd
Twitter: @rtweed

cache.node
• The cache.node interface module allows
you to access a Caché database from
JavaScript

NodeM
• The NodeM module is an Open Source
emulation of cache.node, allowing the
GT.M database to be accessed identically
from JavaScript
– https://github.com/dlwicksell/nodem

ewd-redis-globals
• The Redis-based ewd-redis-globals
implementation of Global Storage includes
an implementation of the cache.node
APIs, allowing the database to be
accessed identically from JavaScript
– https://github.com/robtweed/ewd-redis-globals

cache.node, NodeM &
ewd-redis-globals APIs
When accessed in a QEWD
application:
this.db.{{someFunctioName}}()

Loading and Initialising the
Interface Modules
These steps are done for you
automatically by QEWD
Here’s how to do it manually, eg
if you're creating a standalone
test-harness…

cache.node APIs
Loading cache.node:
var interface = require('cache');
var db = new interface.Cache();

cache.node APIs
Opening connection to Caché :
db.open({
path: '/opt/cache/mgr',
username: '_SYSTEM',
password: 'SYS',
namespace: 'USER',
charset: 'UTF-8',
lock: 0
});

cache.node APIs
Closing connection to Caché:
var ok = db.close();

NodeM (GT.M) APIs
Loading NodeM:
var interface = require('nodem');
var db = new interface.Gtm();

NodeM APIs
Opening connection to GT.M:
db.open();

NodeM APIs
Opening connection to GT.M:
db.open();
Thereafter, all APIs are identical to those used with cache.node

NodeM APIs
Closing connection to GT.M:
ie: Identical to cache.node

Loading ewd-redis-globals:
var interface = require('ewd-redis-globals');
var db = new interface();

Opening connection to Redis / ewd-redis-globals:
db.open();

Thereafter, all APIs are identical to those used with cache.node
Opening connection to Redis / ewd-redis-globals:
db.open();

Closing connection to Redis / ewd-redis-globals:
ie: Identical to cache.node

Setting up a test harness
• Ready to use example for Caché in
QEWD:
– C:qewdnode_modulesqewdexampletest.js
– Needs editing to match your Caché (or other
database) configuration
• Use previous slides for GT.M and Redis

Edit test.js
console.log('db: ' + JSON.stringify(db));
// Change these parameters to match your GlobalsDB or Cache system:
var ok = db.open({
path: '/opt/cache/mgr',
password: 'SYS',
namespace: 'USER'
});
console.log('ok: ' + JSON.stringify(ok));
console.log(db.version());
var node = {
global: 'rob',
subscripts: [1],
data: 'hello'
};
db.set(node);
var result = db.get(node);
console.log(JSON.stringify(result));
db.close();

Edit test.js
var ok = db.open({
path: 'C:InterSystemsCache2015-2mgr',
password: 'SYS',
namespace: 'USER'
});
var node = {
global: 'rob',
subscripts: [1],
data: 'hello'
};
db.set(node);
db.close();

Save as C:qewdtest.js
var ok = db.open({
path: 'C:InterSystemsCache2015-2mgr',
password: 'SYS',
namespace: 'USER'
});
var node = {
global: 'rob',
subscripts: [1],
data: 'hello'
};
db.set(node);
db.close();

Run it
cd qewd (or on Linux / Raspberry Pi: cd /qewd )
node test

Run it
cd qewd
node test
db: {}
ok: {"ok":1,"result":1,"cache_pid":2960}
Node.js Adaptor for Cache: Version: 1.1.113 (CM); Cache Version: 2015.2 build 66
4
{"global":"rob","subscripts":[1],"data":"hello","ok":1,"defined":1}

One difference between test harness
and QEWD
• Test harness: invoke cache.node APIs
using:
– db.xxx()
• In QEWD worker module, they are
accessed using:
– this.db.xxx()

and QEWD
• Test harness: invoke cache.node APIs
using:
– db.xxx()
db.set(node);
db.close();

and QEWD
• In QEWD worker module:
– this.db.xxx()
• Note: QEWD opens the database automatically when a worker is
started, and closes it automatically when the worker is stopped
this.db.set(node);
var result = this.db.get(node);

The Basic Global Storage APIs

Global Storage handling APIs
Accessing global nodes:
- set
- get
- delete (kill)

Defining a Global Node:
var node = {
global: 'employee',
subscripts: [123456, 'name']
};

Defining a Global Node:
var node = {
global: 'employee',
subscripts: [123456, 'name']
};
employee(123456,"name")

- set
node.data = 'Rob Tweed';
this.db.set(node);

- get
var value = this.db.get(node).data;

- kill
this.db.kill(node);

Traversing Global Subscripts

Traversing global nodes:
- Iterate through subscripts

- Iterate through subscripts at a particular hierarchy level
myGlobal("a")=123
myGlobal("b","c1")="foo"
myGlobal("b","c2")="foo2"
myGlobal("d","e1","f1")="bar1"
myGlobal
"a" 123
"b"
"c2" "foo2"
"d"
"c1" "foo"
"e2"
"e1"
"f2" "bar2"
"f1" "bar1"
"f2" "bar2"
"f1" "bar1"
"f3" "bar3"
"a", "b", "d"

myGlobal("a")=123
myGlobal
"a" 123
"b"
"c2" "foo2"
"d"
"c1" "foo"
"e2"
"e1"
"f2" "bar2"
"f1" "bar1"
"f2" "bar2"
"f1" "bar1"
"f3" "bar3"
"e1", "e2"

myGlobal("a")=123
myGlobal
"a" 123
"b"
"c2" "foo2"
"d"
"c1" "foo"
"e2"
"e1"
"f2" "bar2"
"f1" "bar1"
"f2" "bar2"
"f1" "bar1"
"f3" "bar3"
"f1", "f2", "f3"

"f1", "f2", "f3"
To achieve the following traversal:

Traversing Global Node:
var node = {
global: 'myGlobal',
subscripts: ['d', 'e2', '' ]
};
"f1", "f2", "f3"

var node = {
global: 'myGlobal',
};
"f1", "f2", "f3"
"seed" value to start iterator
Empty string

var node = {
global: 'myGlobal',
};
var subscript = this.db.order(node).result;
// 'f1'
"f1", "f2", "f3"

var node = {
global: 'myGlobal',
};
// 'f1'
subscript = this.db.order(node).result;
// 'f2' myGlobal("d","e2","f1")="bar1"
"f1", "f2", "f3"

var node = {
global: 'myGlobal',
};
// 'f1'
// 'f2'
// 'f3'
"f1", "f2", "f3"

var node = {
global: 'myGlobal',
};
// 'f1'
// 'f2'
// 'f3'
// ''
"f1", "f2", "f3"

var node = {
global: 'myGlobal',
subscripts: ['d', 'e2', 'f2' ]
};
// 'f3'
"f3"
"seed" value to start iterator
Start from f2

// 'f3'
node is now:
{
global: 'myGlobal',
};

var node = {
global: 'myGlobal',
};
// 'f3'
// '' myGlobal("d","e2","f1")="bar1"
""
Empty string means no further subscripts, so traversal is complete

Traversing Global Node – generic loop:
var node = {
global: 'myGlobal',
};
var subscript;
do {
if (subscript !== '') console.log(subscript);
}
while (subscript !== '');
"f1", "f2", "f3"

The APIs are low-level
• Deliberately designed to provide the basic
means of access to Global Storage and nothing
more
• They assume you understand the mechanics of
Global Storage
• Too low-level for JavaScript development
– Traversal, in particular, requires a lot of code
• However, they can be abstracted to a more
JavaScript-centric point of view
– Which is the subject of the next part of this course

EWD 3 Training Course Part 19: The cache.node APIs

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Destacado

Destacado (11)

Similar a EWD 3 Training Course Part 19: The cache.node APIs

Similar a EWD 3 Training Course Part 19: The cache.node APIs (20)

Más de Rob Tweed

Más de Rob Tweed (10)

Último

Último (20)

EWD 3 Training Course Part 19: The cache.node APIs