EWD 3 Training Course Part 25: Document Database Capabilities

Copyright © 2016 M/Gateway Developments Ltd
EWD 3 Training Course
Part 25
JavaScript Abstraction of Global Storage:
Global Storage as a
Document Database
Rob Tweed
Director, M/Gateway Developments Ltd
Twitter: @rtweed

1-1 correspondence
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: {
e1: {
f1a: 'bar1a',
f2a: 'bar2a'
},
e2: {
f1b: 'bar1b',
f2b: 'bar2b',
f3b: 'bar3b'
}
}
}
myDoc("a")=123
myDoc("b","c1")="foo"
myDoc("b","c2")="foo2"
myDoc("d","e1","f1a")="bar1a"
myDoc("d","e2","f1b")="bar1b"
Global Storage
JavaScript Object

DocumentNode methods for document database / JSON mapping:
getDocument()
setDocument()
Document Database Methods

Instantiate a DocumentNode Object
var doc = new this.documentStore.DocumentNode('myDoc');
myDoc("a")=123

getDocument()
var myObj = doc.getDocument();
myDoc("a")=123
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: {
e1: {
f1a: 'bar1a',
f2a: 'bar2a'
},
e2: {
f1b: 'bar1b',
f2b: 'bar2b',
f3b: 'bar3b'
}
}
}
creates

getDocument()
var myObj = doc.getDocument();
myDoc("a")=123
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: {
e1: {
f1a: 'bar1a',
f2a: 'bar2a'
},
e2: {
f1b: 'bar1b',
f2b: 'bar2b',
f3b: 'bar3b'
}
}
}
myObj is a standard in-memory JavaScript object
containing a copy of the data that was held within
the DocumentNode's sub-tree of nodes
creates

setDocument()
var myObj = { // create the object shown to the right };
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: {
e1: {
f1a: 'bar1a',
f2a: 'bar2a'
},
e2: {
f1b: 'bar1b',
f2b: 'bar2b',
f3b: 'bar3b'
}
}
}

setDocument()
// doesn't yet exist on disk myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: {
e1: {
f1a: 'bar1a',
f2a: 'bar2a'
},
e2: {
f1b: 'bar1b',
f2b: 'bar2b',
f3b: 'bar3b'
}
}
}

setDocument()
doc.setDocument(myObj);
myDoc("a")=123
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: {
e1: {
f1a: 'bar1a',
f2a: 'bar2a'
},
e2: {
f1b: 'bar1b',
f2b: 'bar2b',
f3b: 'bar3b'
}
}
}
creates

setDocument()
doc.setDocument(myObj);
myDoc("a")=123
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: {
e1: {
f1a: 'bar1a',
f2a: 'bar2a'
},
e2: {
f1b: 'bar1b',
f2b: 'bar2b',
f3b: 'bar3b'
}
}
}
myDoc is created on disk, containing a copy of
the data that was held within the myObj
object, now mapped to Global Storage nodes
creates

Applicable for Any DocumentNode
These methods can be applied at any level within an on-disk Document
var dnode = new this.documentStore.DocumentNode('myDoc', ['d' ]);
myDoc("a")=123

var myObj = dnode.getDocument();
myDoc("a")=123
myObj = {
e1: {
f1a: 'bar1a',
f2a: 'bar2a'
},
e2: {
f1b: 'bar1b',
f2b: 'bar2b',
f3b: 'bar3b'
}
}

var myObj = dnode.getDocument();
myDoc("a")=123
myObj = {
e1: {
f1a: 'bar1a',
f2a: 'bar2a'
},
e2: {
f1b: 'bar1b',
f2b: 'bar2b',
f3b: 'bar3b'
}
}
myObj is created from just the sub-tree
of Nodes under myDoc("d")

myDoc("a")=123
myObj = {
g: 1000,
h2: {
w1: 'foo',
w2: 'bar'
}
}

dnode.setDocument(myObj);
myDoc("a")=123
myDoc("d","g")=1000
myDoc("d","h2","w1")="foo"
myDoc("d","h2","w2")="bar"
myObj = {
g: 1000,
h2: {
w1: 'foo',
w2: 'bar'
}
}

What if there's an overlap?
myDoc("a")=123
myObj = {
e2: {
f3b: 'new value',
f4b: 'bar4b'
},
g: 1000,
h2: {
w1: 'foo',
w2: 'bar'
}
}
?

Effectively a merge: new replaces old
myDoc("a")=123
myDoc("d","e2","f3b")="new value"
myDoc("d","g")=1000
myObj = {
e2: {
f3b: 'new value',
f4b: 'bar4b'
},
g: 1000,
h2: {
w1: 'foo',
w2: 'bar'
}
}

Unless you delete the DocumentNode first
dnode.delete();
myObj = {
e2: {
f3b: 'new value',
f4b: 'bar4b'
},
g: 1000,
h2: {
w1: 'foo',
w2: 'bar'
}
}
myDoc("a")=123

dnode.delete();
myObj = {
e2: {
f3b: 'new value',
f4b: 'bar4b'
},
g: 1000,
h2: {
w1: 'foo',
w2: 'bar'
}
}
myDoc("a")=123

dnode.delete();
myObj = {
e2: {
f3b: 'new value',
f4b: 'bar4b'
},
g: 1000,
h2: {
w1: 'foo',
w2: 'bar'
}
}
myDoc("a")=123
myDoc("d","e2","f3b")="new value"
myDoc("d","g")=1000

Advanced features of
getDocument() and setDocument()

Mapping Arrays
myDoc("a")=123
myDoc("d",0)="value0"
Arrays in Global Storage are
by convention only, using
consecutively numbered
integers as subscript values

Mapping Arrays
myDoc("a")=123
Arrays in Global Storage are
by convention only, using
consecutively numbered
integers as subscript values
In legacy applications,
numbering is usually from 1

Mapping Arrays
var myDoc = new this.documentStore.DocumentNode('myDoc');
var myObj = myDoc.getDocument();
myDoc("a")=123
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: {
"0": "value0",
"1": "value1",
"2": "value2",
"3": "value3",
"4": "value4",
"5": "value5",
"6": "value6"
}
}
getDocument() maps these to an object

Mapping Arrays
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value0",
"value1",
"value2",
"value3",
"value4",
"value5",
"value6"
]
}
Why is d not mapped to a JavaScript array?
myDoc("a")=123
?

Mapping Arrays
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value0",
"value1",
"value2",
"value3",
"value4",
"value5",
"value6"
]
}
Well, what if item 2 didn't exist on disk?
myDoc("a")=123

Mapping Arrays
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value0",
"value1",
"value3",
"value4",
"value5",
"value6"
]
}
Element numbers no longer match
myDoc("a")=123
myObj.d[2]myDoc("d",3)

Mapping Arrays
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value0",
"value1",
"value3",
"value4",
"value5",
"value6"
]
}
Which is a problem if we use setDocument() again
myDoc("a")=123

Mapping Arrays
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value0",
"value1",
"value2",
"value3",
"value4",
"value5",
"value6"
]
}
And what if there was a non-integer subscript
breaking the sequence?
myDoc("a")=123
myDoc("d","foo")="bar"
?

Mapping Arrays
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value0",
"value1",
"value2",
"value3",
"value4",
"value5",
"value6"
]
}
Perhaps only map to array if subscripts are an
un-broken sequence of integers?
myDoc("a")=123

Mapping Arrays
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: {
"0": "value0",
"1": "value1",
"2": "value2",
"3": "value3",
"4": "value4",
"5": "value5",
"6": "value6"
'foo": "bar"
}}
myDoc("a")=123
myDoc("d","foo")="bar"

Mapping Arrays
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value0",
"value1",
"value2",
"value3",
"value4",
"value5",
"value6"
….
"not good"
]
}
- this would have big performance implications
myDoc("a")=123
…. etc
myDoc('d",301839979)="not good!"

Mapping Arrays
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value0",
"value1",
"value2",
"value3",
"value4",
"value5",
"value6"
….
"not good"
]
}
- this would have big performance implications
- every subscript value would need checking!
myDoc("a")=123
…. etc
myDoc('d",301839979)="not good!"
Could be millions to check!

Mapping Arrays
myDoc("a")=123
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: {
"0": "value0",
"1": "value1",
"2": "value2",
"3": "value3",
"4": "value4",
"5": "value5",
"6": "value6"
}
}
getDocument() maps these to an object for performance

Mapping Arrays
var myObj = myDoc.getDocument(true);
myDoc("a")=123
If the Global node tree is small, you can force mapping
To an array for continuous integer subscript values starting 0
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value0",
"value1",
"value2",
"value3",
"value4",
"value5",
"value6"
]
}

Mapping Arrays
myDoc.setDocument(myObj)
myDoc("a")=123
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: {
"0": "value0",
"1": "value1",
"2": "value2",
"3": "value3",
"4": "value4",
"5": "value5",
"6": "value6"
}
}
and for guaranteed unambiguous mapping to/from JavaScript objects

Using Mapped Arrays
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: {
"0": "value0",
"1": "value1",
"2": "value2",
"3": "value3",
"4": "value4",
"5": "value5",
"6": "value6"
}
}
for (var index in myObj.d) {
console.log('element ' + index: ' + myObj.d[index]);
}
Just have to use a for..in loop
instead of a forEach one

What about JavaScript Arrays?
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value0",
"value1",
"value2",
"value3",
"value4",
"value5",
"value6"
]
}
JavaScript has a formal array type
eg myObj.d is a JavaScript array

What about JavaScript Arrays?
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value0",
"value1",
"value2",
"value3",
"value4",
"value5",
"value6"
]
}
JavaScript has a formal array type
eg myObj.d is a JavaScript array
How does setDocument() handle these?

setDocument() mapping of Arrays
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value0",
"value1",
"value2",
"value3",
"value4",
"value5",
"value6"
]
}
myDoc("a")=123
myDoc.delete();
myDoc.setDocument(myObj);

myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value0",
"value1",
"value2",
"value3",
"value4",
"value5",
"value6"
]
}
myDoc("a")=123
myDoc.delete();
Mapping is to a zero-based sequence of integer subscripts

Mapping legacy Global Storage
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value1",
"value2",
"value3",
"value4",
"value5",
"value6"
]
}
myDoc("a")=123
myDoc.delete();
What about legacy Mumps integration, where numbering starts from 1?
?

myDoc("a")=123
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: {
"1": "value1",
"2": "value2",
"3": "value3",
"4": "value4",
"5": "value5",
"6": "value6"
}
}
getDocument() mapping will work correctly

myDoc.delete()
myDoc("a")=123
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: {
"1": "value1",
"2": "value2",
"3": "value3",
"4": "value4",
"5": "value5",
"6": "value6"
}
}
And the reverse mapping from the object will work correctly

myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value1",
"value2",
"value3",
"value4",
"value5",
"value6"
]
}
myDoc("a")=123
myDoc.delete();
But setDocument() mapping from arrays is 0 based

myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value1",
"value2",
"value3",
"value4",
"value5",
"value6"
]
}
myDoc("a")=123
myDoc.delete();
var offset = 1;
myDoc.setDocument(myObj, offset);
..unless you apply an offset as a 2nd argument

Mapping Arrays
var offset = 1;
var myObj = myDoc.getDocument(true, offset);
myDoc("a")=123
If the Global node tree is small, you can force mapping
To an array for continuous integer subscript values starting 0
myObj = {
a: 123,
b: {
c1: 'foo',
c2: 'foo2'
},
d: [
"value1",
"value2",
"value3",
"value4",
"value5",
"value6"
]
}

Uniquely Powerful Document Database
• Fine-grained
– ie can be applied at any level within an on-disk
Document
– Save large document using setDocument()
– Retrieve sub-section via getDocument() applied to an
intermediate DocumentNode
– Can even read/write at the individual name/value pair
level anywhere within an on-disk Document
• Using value property of the DocumentNode

EWD 3 Training Course Part 25: Document Database Capabilities

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to EWD 3 Training Course Part 25: Document Database Capabilities

Similar to EWD 3 Training Course Part 25: Document Database Capabilities (20)

More from Rob Tweed

More from Rob Tweed (17)

Recently uploaded

Recently uploaded (20)

EWD 3 Training Course Part 25: Document Database Capabilities