Author Archives: ksbhaskar

Graphical Monitoring of Statistics Shared by Processes

Quick Start

Monitor the shared database statistics of your existing applications in minutes, starting right now.

  • Ensure that node.js is installed.
  • Use the ydbinstall script to install the YottaDB GUI. (This also installs the YottaDB web server.)
  • Ensure that in the environment of each application process, the variable ydb_statshare is set to 1.
  • Start the YottaDB web server using the same global directory as your application.
  • Connect to the web server to start the YottaDB GUI. In the Dashboard, choose Database Administration / Monitor Database. Choose the data you want to monitor, and choose how you want it displayed. Click Start to see the data.

The GUI comes with a demo that includes a simulated application. This video walks you through using the demo.

Read on to dig deeper.

Motivation

Visual presentation is the most effective way most of us ingest complex data.Napoleon's disastrous march on Moscow As with the unique Minard depiction of Napoleon’s disastrous march on Moscow shown here, we routinely use graphs every day.

Processes accessing databases have tens of internal counters (collectively referred to as “statistics”) for each database file that they have open. The YottaDB GUI allows you to visually monitor these statistics in real time.

Statistics

There are two sources of statistics to monitor: statistics shared by processes and statistics in the database file header. Each has its uses.

Shared Statistics

YottaDB processes can opt to share their operational database statistics. If at process startup, the environment variable ydb_statshare is 1. Optionally, the environment variable ydb_statsdir can be set to a temporary directory for sharing and monitoring.

File Header Statistics

Statistics in the database file header capture the aggregate data of all processes accessing the database from the database creation. Viewing these statistics requires access to the database file but does not require application processes to share statistics.

Monitoring

Shared Statistics

Monitoring statistics shared by processes enables focused analysis, for example, visualization of current performance issues and the behavior of specific processes. The YottaDB GUI provides graphical monitoring of shared statistics.

With the intent of ensuring that it is intuitive to use, the GUI has integrated online documentation, including mouse-overs, but no separate user documentation other than installation instructions.

This video on this page walks you from start to finish, to graphically monitor statistics of an existing application on a remote server.

If you want to implement your own monitoring of shared statistics, YottaDB provides a %YGBLSTAT() utility program.

File Header Statistics

For production instances, we recommend continuously capturing statistics every minute or so. You can use the gvstat program program or write your own similar program. Capturing the data and creating baselines will help you in capacity planning as well as incident analysis. Continuously monitoring and displaying key parameters can additionally give you insight into the dynamic behavior of your application.

The guest blog post YottaDB Dashboard by Ram Sailopal demonstrates monitoring File Header Statistics with Grafana.

Security

Statistics are metadata, not data. While metadata should be shared advisedly, it does not typically have the same confidentiality restrictions as data. The GUI and web server follow normal YottaDB security policies.

  • Processes must opt-in to share statistics.
  • The web server process must be started by a userid on the system, and has no access capabilities beyond those of that userid.
  • Database monitoring can be performed by a read-only GUI. You can see from the videos that the GUI is operating in read-only mode.
    • While the GUI does have a read-write mode, for example, to support editing of global directories, database monitoring requires just read-only access.
  • To access statistics, the web server needs access to the global directory and the $ydb_statsdir directory if it is specified. You can use Linux permissions to control access.
    • The JavaScript libraries used are mature, versioned, and statically served from where the GUI is installed on the server.

Please Try It!

We invite you to use the GUI to monitor database statistics shared by your application processes and tell us what you think. As it is a new application, we are sure that it offers many opportunities for enhancement and improvement.

  • If you have YottaDB support, please reach out to us through your YottaDB support channel.
  • If you do not have YottaDB support, you can reach out to us:

Thank you for using the YottaDB GUI.

Making lua–yottadb Fast

Berwyn Hoyt

We thank Berwyn Hoyt for his first guest post on the YottaDB blog, and hope there are many more to follow. If you would like to post on the YottaDB blog please contact us at info@yottadb.com.

TLDR: YottaDB is a fast and clean database and it deserves a Lua API that is as fast as possible. This article discusses how we improved lua-yottadb to go ~4× as fast when looping through database records, and a stunning 47× as fast when creating Lua objects for database nodes, plus other improvements (results here). Low-hanging fruit aside, the biggest (and trickiest) improvement was caching the node’s subscript array in the Lua object that references a specific database node. Finally, porting to other language wrappers is discussed, as well as a tentative thought on how YDB might support an even faster API. Along the way we learned numerous things that might help someone port these efficiencies to other languages.


I had recently released v1.0 of lua-yottadb,1 a syntax upgrade to a tool that gives Lua easy access to YottaDB. Then in Oct 2022, I got my first user: Alain Descamps, of the University of Antwerp Library (sponsors of lua-yottadb), and a heavy user of YottaDB. An actual user. Brilliant!

But the euphoria didn’t last long. Mere hours later, I got Alain’s first benchmark: Lua was ¼ of the speed of YottDB’s native language (M) at simply traversing (counting) database records on our dev server. Even worse, when run on my local PC’s database, Lua was th the speed of M. Grrr… So I embarked on what I thought would be a 5-day pursuit of efficiency … but it took 25 days! Nevertheless, I did get the dev server’s Lua time down from 4× to 1.3× the duration of M. A very nice result.

What was the problem?

Alain’s Lua benchmark script was simple – akin to this:

ydb = require('yottadb')
gref1 = ydb.key('^BCAT')('lvd')('')
cnt = 0  for x in gref1:subscripts() do  cnt=cnt+1  end
print("total of " .. cnt .. " records")

If you’re new to YottaDB or M, to understand what’s going on, you need to know that YottaDB database nodes are represented by a series of ‘subscript’ strings, just like a file-system path. Whereas a path might be /root/var/log/file, a YottaDB node would be root("var","log","nodename") or root.var.log.nodename. Each node can hold a bit of data, further sub-nodes (similar to directories in a file-system), or both.

The program above simply loops through a sequence of 5 million database nodes with subscripts ^BCAT.lvd.<n> like so:

^BCAT("lvd",1)
^BCAT("lvd",2)
^BCAT("lvd",3) ...

To do so took 20 seconds in Lua, and 5 seconds in M. A quick code review of lua-yottadb found a number of low-hanging fruit in the gref1:subscripts() method above. The issues were that for every loop iteration, gref1:subscripts() did this:

  1. Checked each subscript in the node’s ‘path’ at the Lua level to make sure it was a valid string.
  2. Checked each subscript again at the C level.
  3. Converted the subscript array into a C array of string pointers (for calling the YottaDB API), then discarded the C array.

Yep. All that happened at every iteration.

Next, I built some benchmarks tests to track our improvement, then got stuck into improving things.2 Avoiding number (3) would require caching of the C array. But we could avoid (1) and maybe (2) by checking them just once at the start of the loop. This was fairly quickly done, with respectable improvements to iteration speed, including:

But what if we wanted to improve every single database operation, not just iteration? The benchmarks showed that there were two slow tasks critical to every single database operation: a) converting the subscript list to C, and b) creating new Lua nodes.

As an example of the latter, let’s create a Lua-database object:

guy = ydb.node('demographics').country.person[3]

We can do all kinds of database activities on that node, for example:

node:lock_incr()
node:set('Fred')
node:lock_decr()

or even create subnodes:

guy.gender:set('male')
guy.genetics.chromosome:set('X')

Each '.' above creates a new Lua subnode object (in this case, genetics and then chromosome) before you can finally set it to 'X'. You can imagine that a Lua programmer will be doing a lot of this, so it’s a critical task: we need to optimise node creation.

To achieve this we needed to find the ‘Holy Grail’: fast creation of cached C arrays. That would extend these benefits to every database function.

My early wins made it feel like I was about half way there. I’d told my employer the efficiency task would take 5 days. By this time I’d used up about half of that, and I thought I was on track. All that was left was to cache the subscript list. I mean, how hard can it be to cache something? You just have to store the C array when the node is first created, and use it again each time the node is accessed, right? Little did I know!

Caching subscripts: a surprisingly daunting task

Achieving these two goals together proved to be so difficult that it took me three rewrites.

At the outset, each node already held all its subscripts – but in Lua, rather than C. The node object looked like this:

node = {
    __varname = "demographics"
    __subsarray = {"country", "person", "3", "gender"}
}

Be aware that creating a table in Lua is slow compared to a C array: it requires a malloc(), linkage into the Lua garbage collector, a hash table, and creation of a numerical array portion. And here we need two of them (one for the node object itself, and another for the __subsarray). So it’s relatively slow. But at this point I didn’t know that this was the speed hog.

Iteration 1: An array of strings

In the first 2 iterations, I simply stored the C cache-array as a userdata field within the regular node object as follows (userdata is a Lua type that represents a chunk of memory allocated by Lua for a C program):

node.__cachearray = cachearray_create("demographics", "country", "person", "3", "gender")

Since Lua already referenced the strings in __subsarray (presented previously), my function cachearray_create() just had to allocate space for it: malloc(depth*string_pointers), and point them to the strings already existing in Lua. But this would mean I had to retain the __subsarray table to reference these strings and prevent Lua from garbage-collecting them while in use by C.

Although this caching would speed up node re-use, adding __cachearray to the node would actually slow down node creation time. To prevent the slow-down, I noticed that each child node repeats all its parent’s subscripts. So I saved both memory and time, by making each child node object contain only its own rightmost subscript __name and point to __parent for the rest:

node = {
    __varname = "demographics"
    __name = "gender"
    __parent = parent_node      -- in this case, "3"
}

This way I avoid having to create the whole Lua __subsarray table for each node. So each node contains a linked list to its __parents: gender -> 3 -> person -> country.

If you’re getting bored at this point, I suggest you skip to iteration 3.

Segfaults and Valgrind

That was the design for iteration 1. But the __parent made it complicated, because I had to create the cache-array by recursing backwards into all the node’s ancestors. This complexity hid a nasty segfault that I couldn’t find for a long time: the kind of C pointer bug where the symptom occurs nowhere near the cause. (I should have used valgrind myprog to help find it, but I hadn’t used Valgrind before, and I didn’t realise how dead simple it was to use. Later, I needed it again, and discovered that using it is true bliss.)

Anyway, the bug ended up being a case of playing “where’s Wally” except with hidden asterisks. The code was: malloc(n_subscripts * sizeof(ydb_buffer_t*)), except I shouldn’t have included the final * because the YDB API uses an array of buffer structs, not pointers to structs. In the end I found the bug by manually running Lua’s collectgarbage() – which often makes memory errors occur sooner rather than later.

Fast traversal: ‘mutable’ nodes

Finally, we had a node with cache – for fast access to the database. But we still didn’t have fast node traversal, like in Alain’s tests. This is because each time you iterate Alain’s for loop, you have to create a new node: ^BCAT(“lvd”,1) ^BCAT(“lvd”,2), etc. So I made the function cachearray_subst() re-use the same array, altering just the last subscript.

But changing a node’s subscripts is dodgy. It makes the same node object in Lua refer to a different database node than it used to. Imagine that you’re the programmer and have stored that Lua object for use later (e.g., when scanning through to find the highest value node: maxnode = thisnode).3 You’ll still be expecting the stored maxnode to point to the maximum node.

Enter the concept of a ‘mutable’ node, which the programmer explicitly expects to change. Lua iterators like pairs() can now return specifically mutable nodes. The programmer can convert this to an immutable node if they want to store it for use after the loop, or they can test for mutability using the ismutable() method.

Well, it worked. Now we have a lightning-fast iterator, and in most cases the programmer doesn’t have to worry about mutability.

Garbage collection & Lua versions

All that remained was to tell Lua’s garbage collector about my mallocs. In Lua 5.4 this would have been easy: just add node method __gc = cachearray_free to the object. But __gc doesn’t work in Lua 5.1 on tables (which is what our node object is), and we wanted lua-yottadb to support Lua 5.1 since LuaJIT is stuck on the Lua 5.1 interface – so some people still use Lua 5.1. Instead of simply setting __gc = cachearray_free, I had to allocate memory using Lua’s “full userdata” type, which is slower than malloc, but at least it provides memory that is managed by Lua’s garbage collector.4

Lastly, I wrote some unit tests, and I thought I’d be done. But node creation wasn’t really any faster.

Iteration 2: A shared array of strings

At this stage I’d already spent 12 days: over twice as long as I’d anticipated. That’s not too outrageous for a new concept design. Strictly, I should have told my employer that I was over-budget, so they could make the call on further development. But I was embarrassed that my node creation benchmark was not really faster than the original. We had fast iteration now, but I had anticipated that everything would be faster. Something was wrong, and I decided to just knuckle down and find it.

At this point I made a mistaken judgment-call that cost development time. I guessed (incorrectly) that the speed issues were because each node creation had to copy its parent’s array of string pointers. Instead of verifying my theory, I implemented a fix, adding complexity as follows.

Each child node retained a duplicate copy of the entire C array of string-pointer structs. But this seemed unnecessary since each child added only one subscript string at the end. Let’s keep just one copy of the C array and have each child node reference the same array but keep its specific depth as follows:

array = cachearray("demographics", "country", "person", "3", "gender")
root_node   = {__cachearray=array, __depth=1}
country_node= {__cachearray=array, __depth=2}
person_node = {__cachearray=array, __depth=3}
id_node     = {__cachearray=array, __depth=4}
gender_node = {__cachearray=array, __depth=5}

This works, but adds some complexity, because if you create alternate subscript paths like: root.person.3.male and then person.4.female. Then the code has to detect that the cache array is already used at subscript 3, so you can’t change it to 4, and you have to create a duplicate cache-array after all. It also complicates the Lua code because the C code now has to return a depth as well as the array.

Although it does speed up node creation, it’s still not as much as expected, because it’s also slowing down node creation simply by adding the __depth field to the object.5

Iteration 3: A breakthrough – the complete object in C

Up to this point I had been assuming I needed a Lua table to create a Lua object. After all, it seemed so efficient to make C just point to the existing Lua strings; and for that I needed Lua to reference those strings to keep them from being garbage collected: hence a Lua table.

But now I finally did some more benchmarking and showed Lua table creation to be the speed hog. Remember: it does a malloc(), links to the Lua garbage collector, creates a hash table, and a numerical array portion. Plus, we’re adding three hashed fields, which are not exactly instant: __parent, __cachearray, and __depth.

It sure would be much faster if we could store all this data inside a C struct. So I read the manual again and discovered that the userdata type can be a Lua object all by itself. I should have guessed this from the start. You can assign a metatable to a userdata – which means that you can give it object methods – which means it can actually be the node object, all by itself. No need to create a Lua table for a C object at all.

Implementing this, my userdata C struct now looks something like this:

typedef struct cachearray_t {
  int subsdata_alloc;   // size allocated for strings (last element)
  short depth_alloc;    // number of pre-allocated array items
  short depth_used;     // number of used items in array
  ydb_buffer_t subs_array[]; // struct reallocated if this exceeded
  char subsdata[];
} cachearray_t;

I pre-allocated space for extra slots (5, by default, before needing reallocation). Thus, when you create ydb.node(“demographics”) you can follow that up with .country.person[3].female and all these subsequent subscripts get stored in the same, previously allocated C-array.

Notice that this struct contains two expanding sections (it’s really two separate structs): the array of string pointers subs_array and the actual string characters subsdata. It would be better to keep these in a single array of structs, and thus have just one expanding section. But we cannot do that because we need an array of ydb_buffer_t to pass to the YDB API. These two expanding sections add complexity to the code, but don’t slow it down. It would be simpler to allocate two userdata sections: one for each section – but that would slow it down.

Also notice that since subsdata now stores subscript strings in my C userdata, I don’t need to keep a Lua table that references their Lua copies, which are now set free.

Anyway, this cache-array can now hold subscripts for several nodes. But I still need to store the depth of each particular node somewhere. For this, I have a ‘dereference’ struct which points to a cache-array and remembers the depth of this particular node.

typedef struct cachearray_dereferenced {
  struct cachearray_t *dereference; // merely points to a cachearray
  short depth; // number of items in this array
} cachearray_dereferenced;

For the root node, I store both the cache-array and this dereference struct in the same userdata. Child nodes only need the dereference struct.6 This dereferencing does add some complexity, but it’s worth it to avoid proliferating duplicate cache-arrays, which would fill up CPU cache and slow things down.

Finally, all subscript strings are cached all in C, and I only need to create a userdata for each node, not a table. The irony is that iteration1’s original motivation to re-use Lua strings was a false economy. It turns out that it’s just as fast to copy the strings into C as it is in Lua to do the necessary check that all subscripts are strings. And it doesn’t even waste any memory, because the Lua strings can then be garbage collected instead of held by reference.

By now, I’ve taken 25 days to implement this thing. I’m going to have some serious explaining to do to my employer. That, in fact, is how this article began.

Iteration 4: The gauntlet challenge – cheap node creation

Virtually instant subnode creation is possible if light userdata were used for it. However, these nodes could never be freed since __gc finalizer methods do not work on light userdata in Lua. Can anyone think of a workaround?

Consider a Lua object for database node demographics. Subnodes can be accessed using dot notation: demographics.country.person. Even with our latest design, subnodes still have the overhead of allocating a full userdata. But Lua has a cheaper type called a light userdata: which is nothing more than a C pointer, and free to create. We just need to pre-allocate space for several dereferenced subnodes (shown below) within the parent node’s userdata, and child nodes could simply point into it:

typedef struct cachearray_t {
    cachearray_dereferenced[5];
    <regular node contents> ...

This will finally make full use of that mistaken judgment-call I made early on, and re-use pre-allocation to ultimate effect.

But there’s a gotcha. Since a light userdata object has no storage, Lua doesn’t know what type of data it is, and therefore what metatable (i.e. object methods) to associate with it. So there’s a single global metatable for all light userdata objects. No matter: we can still hook the global metatable, and then double-check that it points to a cache-array, before running cache-array class methods on it. Should work fine.

Node creation time in lua-yottadb v2.1 is already 47× as fast as v1.2, but I’m anticipating this improvement will increase that to 200x, making dot notation virtually free. This will also keep all allocated memory together in one place: also better for CPU caching.

This hack would actually work … except for one problem: it can’t collect garbage. Tragically, Lua ignores the __gc method on light userdata. This means we’ll never be able to remove the light userdata’s reference to its root node. Which creates a memory leak. Here’s an example to explain:

x = ydb.node("root").subnode
x = nil

First the root node is created; then subnode references root; then Lua assigns subnode to x so that x now references subnode. Finally, x is deleted. The problem is that when x is garbage-collected, Lua does not collect light userdata subnode (which is still referencing root). So root is not collected: a memory leak.

Can any of my readers see a solution to this puzzle? I’m throwing down the gauntlet. Find a way to work around Lua’s lack of garbage collection on light userdata, then post it here, and I’ll make you famous on this blog. 😉

On the other hand, Mitchell has rightly pointed out that this is probably premature optimisation. After profiling, you can easily recover the speed in time-critical code by simply giving up dot notation and creating the node object all at once with ydb.node("demographics", "country", "person").

Portability: Python, etc.

In theory, my final cachearray.c is the best version to port to another language without a complete re-write because it now keeps its strings entirely in C – which means it’s fairly self-contained and portable. Having said that, it will need changes in how it receives function parameters: which is from the Lua stack. The Python/etc. portion of the wrapper will also need extensions to support cache-arrays.

A quick look at Python’s YDBPython, for example, shows that its C code has the same design as the original lua-yottadb – and is probably slow. Every time it accesses the database, it has to verify your subscript list, and copy each string to C. Unlike lua-yottadb, YDBPython also does an additional malloc() for each individual subscript string. Caching the subscript array could provide a significant speedup, just as it did for Lua.

The Python code to create an object also has the same low-hanging fruit as lua-yottadb. But YDBPython has an additional easy one-line win by using __slots__, a Python feature not available in Lua. A quick benchmark tells me that using __slots__ makes python bare object creation 20% faster (though it needs another 25% to be as fast as Lua’s object creation using userdata).

At this stage I do not know much about Python’s C API: neither about Python’s alternatives to userdata objects, nor whether Python has a faster way of implementing dot notation without creating intermediate nodes.

YDB API overhead: a suggestion

After all this work, why is M still faster? I suspect that lua-yottadb is now about as fast as it can get. So why is database traversal in Lua still 30% slower than M (on our server), when a basic for loop in Lua is 17× as fast as M? My hunch was that there are subscript conversion overheads on the YottaDB side of the YottaDB-C API, that M doesn’t incur since YottaDB includes both the YottaDB database and a complete implementation of the M language. I had a chat with Bhaskar, founder of YottaDB, and he was able to confirm my hunch.

Since YottaDB includes both the database engine and the M runtime system, it can make optimizations that another language runtime system cannot make when accessing the database. At a high level, that is why database access from non-M languages can get close to M, but cannot quite match it.

For example, since a value can have multiple representations, e.g., 1234 can be both a string as well as a number, with a cost to convert between representations, YottaDB stores metadata about data that includes the representations it already has. This is a classic trade-off of space for speed. This, and other optimizations, give M an edge over other languages when accessing YottaDB.

However, while database access specifically may be faster in M, performance should always be considered in the context of complete applications, any of which will execute a substantial amount of logic other than just database access. The fact that a basic for loop in Lua is so much faster than one in M may suggest that a complete application coded in Lua will outperform an equivalent application coded in M. So, my employer and I, as well as YottaDB, consider this exercise to be a success.

My work on this project suggests a possible avenue for an enhancement to YDB itself that may be worth considering. Given that languages like Lua and Python access data through node objects, one possibly way to improve performance would be for YDB itself to expose a function to cache a subscript array, storing it as mvals within YDB:

handle = ydb_cachearray("demographics", "country", "person", "3", "gender")

This would return a handle to that YDB-owned cache-array, which could then be supplied to subsequent YDB API calls as the root operating node, instead of the GLVN, varname. This would allow rapid access to the same database node, or rapid iteration through subnodes, without having to re-convert all 5 subscripts on every call.

Of course, this is just a theory. Profiling would first be needed to check whether this conversion process is the actual cause of the speed differential, and how much this solution would typically help.

Lessons

Perhaps most significantly, this article raises some of the significant issues that efficiency improvements in any language will have to work through. Hopefully, this will allow someone to implement it in iteration 1, rather than iteration 3.

Here are a few other take-homes from this experience:

  • Always test your theories about what’s causing the slow-down before implementing a complete fix.
  • Choose benchmarks relevant to your applications, because those will be what you optimise.
  • Communicate with your employer early, even if it’s embarrassing: even the reporting process might expose your assumptions. (I knew this already, but pride got in the way 😳).
  • Useful details about implementing a Lua library in C: speedy userdata, light userdata, and Valgrind for emergencies.

I sure did learn a lot through this process, and I hope you’ve learned something, too.

About Berwyn Hoyt


Berwyn Hoyt is a senior embedded systems engineer, having co-founded two startups in embedded systems. He has lived in the USA and New Zealand most of his life, but has recently moved to Sydney, to be with his wife who now works for a church there. Berwyn loves low-level, efficient software, and puzzles that are difficult. He especially loves ring-and-string puzzles, and has recently had a breakthrough on the extremely difficult Quatro puzzle (pictured), which has amused him, sporadically, for a decade. He has now solved the 3-ring version and is getting ready to tackle all 4 rings.

(All photos courtesy Berwyn Hoyt.)


1 Actually, the release was of lua-yottadb’s companion tool, MLua. The two are closely related, but work in opposite directions: lua-yottadb lets Lua access M, whereas MLua lets M access Lua.
2 Alain’s benchmark was skewed by a curiously slow build of Lua that he used. His sysadmin tells me it was compiled with -O0. He has now compiled it with -O3, which has demonstrably doubled the speed. In any case, the benchmark comparisons I’ve supplied are all from my laptop (the mainframe’s database setup is faster).
3 Worse, when we later introduce cache-array shared with parent nodes, if you create a sub-node out of it and store that, then your sub-node’s parent subscript will get changed, since it uses the same cache-array.
4 Incidentally, this should have been a clue to use the userdata type for the object itself instead of a Lua table, because __gc does work on userdata, in Lua 5.1. But I didn’t get there until iteration 3. At this stage, since Lua 5.1 userdata cannot reference Lua values, I was locked into thinking we still needed a Lua table to store Lua references to the subscript strings.
5 At this point I tried to store the __depth in C by using what Lua calls a ‘C closure’. What I didn’t realise is that although a normal Lua closure can have Lua locals for each instance of a function, a C closure is different: it can only store one set of locals for the entire C library. This didn’t let me store __depth against each node object at all. So that was a wasted attempt.
6 Child nodes also need to Lua-reference their parent to avoid it being garbage collected while they’re pointing to it. Ironically, iteration 3 thus required me to implement what I avoided in iteration 1: a way for Lua 5.1 userdata to reference Lua values.
YottaDB r1.38 Released

YottaDB r1.38 is a minor release that includes functionality needed at short notice by a customer.

  • A MUPIP REPLICATE option provides for a replication stream to include updates made by triggers on the source instance.
  • $ZPEEK() and ^%PEEKBYNAME() provide direct access to an additional process-private structure.
  • The -gui option of ydbinstall / ydbinstall.sh installs the YottaDB GUI.
  • Changes to subscripts and more meaningul SQL column names make %YDBJNLF more useful.

The %YDBJNLF utility program, which was released as field-test software in r1.36, is considered Supported for production use in r1.38. Also, the Supported level of Ubuntu on x86_64 moves up from 20.04 LTS to 22.04 LTS.

While all YottDB software is free to use under our free / open-source software licensing, r1.38 illustrates the value of being a YottaDB customer rather than a user: in addition to support with assured service levels, we will work with you to prioritize enhancements and fixes you need.

As with all YottaDB releases, there are a number of fixes and smaller enhancements, as described in the release notes.

We also invite you to try the new YottaDB GUI.

YottaDB r1.34 Released

While YottaDB r1.34 is an otherwise modest successor to r1.32, internal changes allow the popular programming language Python to be fully Supported. We are excited about making YottaDB available to the large Python user community. Here is a “Hello, World” Python program that updates the database and illustrates YottaDB’s Unicode support:

import yottadb

if __name__ == "__main__":
yottadb.set("^hello", ("Python",), value="नमस्ते दुनिया")

The Python wrapper can be installed with pip install yottadb. Full details of the API are in the Python wrapper user documentation. The current Debian Docker image at Docker Hub includes the Python wrapper. We thank Peter Goss (@gossrock) for his contributions to the Python wrapper.

Python joins C, Go, M, node.js, Perl, and Rust as languages with APIs to access YottaDB.

Owing to an internal change required to support the Python wrapper, application code written in Go and Rust will need to be compiled with new versions of the Go and Rust wrappers. We anticipate no regressions, and apologize for the inconvenience.

As discussed in our blog post Fuzz Testing YottaDB, adding a new type of testing exposed bugs previously neither encountered in our development environment nor reported by a user. Although fuzz testing generates syntactically correct but semantically questionable, contorted code that is unlikely to be part of any real application, the bugs are nevertheless defects. r1.34 includes the first tranche of fixes. As we are dedicating hardware to continuous fuzz testing, future YottaDB releases will include fixes for bugs found by fuzzing. We thank Zachary Minneker of Security Innovation for Fuzz Testing YottaDB and bringing its benefits to our attention.

In addition to fixes for issues, whether found by fuzz testing or otherwise, YottaDB r1.34 has enhancements that make it faster and more friendly, e.g.,

– Faster stringpool garbage collection, thanks to Alexander Sergeev and Konstantin Aristov (@littlecat).
– HOME and END keys work in direct mode for READ, thanks to Sergey Kamenev (@inetstar).
– Multiple improvements to ydbinstall / ydbinstall.sh.
– Enhancements to ydb_env_set to improve performance under some conditions and to be compatible with existing environments created without ydb_env_set.
– Enhancements to the %RSEL utility program.

YottaDB r1.34 also inherits enhancements and fixes from GT.M V6.3-011.

Details are in the release notes.

YottaDB r1.32 Released

Although there is no single theme to YottaDB r1.32, it qualifies as a major release because it includes a significant number of enhancements, including several to enable the Application Independent Metadata plugin. The plugin provides functionality for applications to push responsibility for maintaining cross references and statistics to YottaDB triggers, thereby reducing the code that applications must maintain. Enhancements include:

  • The $ZYSUFFIX() function enables applications to create variable and routine names that are guaranteed for all practical purposes to be unique, as it uses the 128-bit MurmurHash3 non-cryptographic hash.
  • A $ZPARSE() option to follow symbolic links.
  • Sourcing ydb_env_set creates and manages a three-region database, and defaults to UTF-8 mode.
  • An option to allow $ZINTERRUPT to be invoked for the USR2 signal.
  • The --aim option of ydbinstall / ydbinstall.sh installs the Application Independent Metadata plugin.
  • Shell-like word expansion with $VIEW(“WORDEXP”).
  • Propagation downstream of context set by triggers.
  • ydb_ci_*() functions return the ZHALT argument for C code that calls M code which terminates with a ZHALT.

From the upstream GT.M V6.3-009 and GT.M V6.3-010, which are included in the r1.32 code base, there are enhancements to operational functionality.

There are numerous smaller enhancements that make system administration and operations (DevOps) friendlier, and easier to automate. For example, %PEEKBYNAME() has an option to query global directory segments without opening the corresponding database files, orphaned relinkctl files are automatically cleaned up, and the --octo option of ydbinstall / ydbinstall.sh installs Octo such that octo --version reports the git commit hash of the build.

2020 Holiday Greetings

We wish you and yours a Merry Christmas, Happy Hannukah, Joyous Kwanzaa, Bright Karthigai – whatever you choose to celebrate this holiday season – and a Happy New Year. We hope all is well with you and yours, and that 2021 brings more sanity than 2020 did.

YottaDB moved to 100% telecommuting in mid-March, and we have been working remotely since then. We anticipate returning to the office after the pandemic; meanwhile, the office is for computers and the occasional cobweb.

Nevertheless, we have been busy this year. Our major milestone was the release of Octo 1.0, for querying YottaDB databases using SQL-92 and JDBC. Our next major target for Octo is read-write capability using SQL. Although the following is very much code that is under development, this demonstration of INSERT INTO will give you a taste of what we plan to release in 2021:

$ echo "create table usstates(state varchar primary key, capital varchar);" | octo
OCTO> create table usstates(state varchar primary key, capital varchar);
OCTO> 
$ echo "create table uspresidents (id integer primary key, firstname varchar, middlename varchar, lastname varchar)" | octo
OCTO> create table uspresidents (id integer primary key, firstname varchar, middlename varchar, lastname varchar)
OCTO> 
$ head -3 ~/.yottadb/usstates.sql
INSERT into USSTATES values
       ("Alabama",      "Montgomery"),
       ("Alaska",       "Juneau"),
$ head -3 ~/.yottadb/uspresidents.sql 
INSERT into USPRESIDENTS values
       (1,      "George", "",    "Washington"),
       (2,      "John",   "",    "Adams"),
$ octo -f ~/.yottadb/usstates.sql
$ octo -f ~/.yottadb/uspresidents.sql 
$ echo "select state, capital, id, firstname, middlename, lastname from uspresidents, usstates where lastname = state or lastname = capital;" | octo
OCTO> select state, capital, id, firstname, middlename, lastname from uspresidents, usstates where lastname = state or lastname = capital;
Washington|Olympia|1|George||Washington
Wisconsin|Madison|4|James||Madison
Mississippi|Jackson|7|Andrew||Jackson
Nebraska|Lincoln|16|Abraham||Lincoln
OCTO> 
$

Along with a number of other enhancements and fixes, in our mission to make YottaDB a language-agnostic database, we added support for Rust this year, adding to our support for C, Go and M. From our community, we have support for access to the database from Perl (thanks, Stefan Traby!), and wrappers for access from node.js (thanks, David Wicksell!) and Python (thanks, Peter Goss!) are being worked on by community members. We continue to merge upstream code releases into the YottaDB code base, while ensuring that the merged code meets the standards for robustness, performance, and security that you have come to expect from us.

Since all our software is developed as a 100% free / open source project, you can follow our work at https://gitlab.com/YottaDB. You can see what our development plans are, and you can even see our review comments on our developers’ code Merge Requests. Please do feel free to add your comments to any Issue or Merge Request.

YottaDB continues to grow. We have grown organically from the original three founders to a team of ten. In 2020, we had a table at an international event, FOSDEM 2020, in Brussels. We had more visitors there than all our events in the US in 2019 combined, but after that the pandemic shut down our in-person events. We hope to resume them in due course of time. In 2020, we also refreshed our web site, and we had additional users who permitted us to feature them on our web site.

We send you our hopes and best wishes for good health, happiness and every success in 2021, and hope that we have an opportunity to meet in person in the not too distant future.

What is an Acculturation Guide?

Visiting family in Copenhagen over the holidays at the end of 2019, we were surprised to find Danes carrying packages of fireworks in local trains, which we in the United States would not dream of. Starting around 8pm on New Years Eve, there was a steady and increasing popping of fireworks, and starbursts overhead, leading to a continuous crescendo around midnight. There were fireworks in streets with pedestrian and vehicular traffic, and at one point orange volcano fireworks on the sidewalk across the street were so bright and fiery that they had us rushing to the window to investigate. Crowds gather at Rådhuspladsen, a big plaza outside the Town Hall, with the air thick with smoke. That is Danish culture. Other cultures may celebrateKurdish child in traditional dress for Nowruz their new year by wearing traditional clothes.

So what is culture? According to Wikipedia, it “encompasses the social behavior and norms found in human societies, as well as the knowledge, beliefs, arts, laws, customs, capabilities and habits of the individuals in these groups.” Coming from cultures where you decline until you are pressed when your dinner host or hostess asks whether you want seconds, many an international guest at an American dinner has been dismayed to see dishes carried back to the kitchen!

Acculturation is a process in which an individual adopts, acquires and adjusts to a new cultural environment. As humans, we learn by doing, and immersion is the only road to acculturation.

What does Acculturation mean for software such as YottaDB? You can of course start with “Hello, world” examples that access the database, but what then? The function of a database is persistence: to store data entrusted to it, and provide the stored data when requested. You need to know how to install the software, configure databases to provide business continuity when systems fail or when an entire data center fails, and more.

To that end, we have created the YottaDB Acculturation Guide. It sits between the “Hello, world“ examples and the YottaDB Administration and Operations Guide, which is complete reference material that can appear overwhelming after “Hello, world”.

The one constant about culture is change! Culture is not static. The original Acculturation Guide (sometimes referred to as the Acculturation Workshop) is over ten years old, but has been significantly revamped to reflect YottaDB’s evolution as a language-agnostic NoSQL database, and simpler crash-recovery. As YottaDB gains new functionality and new operational capabilities, we will edit the Acculturation Guide from time to time, adding new material and updating existing content.

Meanwhile, please do try the latest YottaDB Acculturation Guide and tell us what you think.

Images Used:

[1] The Gumpa dance is a special dance celebrated around the time of Losar, the Tibetan New Year. Pictured here in Lachung monastery, North Sikkim, Sikkim, India. Photo by Nichalp downloaded from Wikimedia Commons.

[2] New Years Eve celebration at København Rådhuspladsen. Photo found by and downloaded from Google search. Photographer unknown – please contact us if you are the photographer or copyright holder.

[3] A village girl, Palangan, Kurdistan, Iran. Photo by Salar Arkan downloaded from Wikimedia Commons.

2019 Holiday Greetings and News

As YottaDBⓇ reaches the two and a half year mark, the year-end season is an opportunity for us to reflect on where we started, and where our journey has brought us.

In 2017 three of us started YottaDB, having each worked on GT.M for over twenty years. With a sense of accomplishment, we could point to our contributions. But the GT.M database would never be directly accessed by any language other than M and we believed that the database had value to applications beyond those written in M (see The Anchovy Pizza Company – Not!).

At the end of 2019, we have organically grown to a team of ten. Our office in Malvern, which felt empty when we moved in, will feel cramped when we add our next couple of team members. We anticipate moving to a bigger office when our current lease ends.

In a word, the goal of YottaDBⓇ is persistence. Any application, in any language, and on any platform, should be able to entrust its data to YottaDB. While that may be an overambitious dream, we have a roadmap.

We started by creating a native C API to the database engine. We did this in two stages, first a set of functions for single-threaded applications, and then additional functions for multi-threaded applications. As C is the lingua franca of computer languages because all programming languages have the ability to call C code and be called by it, a high-performance, native C API opened the door to YottaDB access from other languages, using “wrappers”. Our goal with each wrapper is to provide a robust, high-performance API that a programmer in that language would consider intuitive. The first language for which we created a wrapper is Go. Programming YottaDB in Go is now fully Supported with production grade code. In 2020, we hope to release wrappers for Rust and Python, with more languages to follow.

As all of our work is 100% free / open source software (FOSS), our community also contributes software to the YottaDB ecosystem. For example:

  • Nodem (thanks, David Wicksell!) provides a Node.js API to YottaDB.
  • A Perl pod (thanks, Stefan Traby!) provides access from Perl.
  • CFMumps (thanks, John Willis!) provides Cold Fusion Markup Language access to YottaDB.
  • The M Web Server (thanks, Sam Habiel and Christopher Edwards!) provides web services from YottaDB.
  • QEWD (thanks, Rob Tweed!) is a Node.js-based framework for building REST APIs and interactive, real-time web applications, whilst abstracting YottaDB data as on-disk JavaScript objects.
  • Chris Munt’s GitHub page (thanks, Chris Munt!) provides numerous interface packages for YottaDB, as well as his own native SQL engine.

Although YottaDB is a hierarchical key-value NoSQL database, able to handle schemas that are a superset of relational schemas, Octo logomany applications have relational schemas, and even applications with non-relational schemas have relational subsets of their schemas. To accommodate the large number of tools for analytics and reporting of relational data, we are investing heavily developing OctoⓇ, a SQL engine to access relational data in YottaDB databases. Octo CREATE statements define tables and their mapping to YottaDB global variables. Octo compiles SQL queries to native object code that directly accesses YottaDB global variables with minimal overhead.

Throughout our work, we have maintained upward compatibility with upstream GT.M releases. Issues in GT.M addressed during integration with YottaDB code baseWe integrate the code of GT.M releases into the YottaDB code base. As we do this, we create automated regression tests, find, and fix bugs. Upgrading from GT.M to YottaDB is functionally 100% upward compatible, and follows the same steps as upgrading from an older GT.M version to a newer version (conversely, for M application applications, downgrading from YottaDB to GT.M follows the same steps as downgrading from a newer GT.M version to an older one).

YottaDB is a fully open project. This means that when we fix an issue or add an enhancement, under our GitLab projects you can see the code changes, you can see review comments and responses, and you can see associated automated regression tests. So when our release notes mention a fix or enhancement to the software, you have complete traceability to the associated code changes and tests. This traceability adds significant value beyond just having the code for a release available under a FOSS license.

In closing, we would like to take this opportunity to wish you a Merry Christmas, Happy Hanukah, Joyous Kwanzaa – whatever you celebrate this season – as well as a Wonderful New Year in 2020. You make YottaDB possible. We thank you and look forward to serving you in 2020.

The YottaDB Team
in alphabetic order: Bhaskar, Brad, Chris, Ganesh, Jon, Joshua, Matt, Narayanan, Saraswathi, and Steve.
with wags from: Dash and Emmy

YottaDB r1.28 Released

For users of YottaDB using the Go API, r1.28 is a major release because it is required for production grade access to YottaDB from Go. For others, it is a minor release with a small set of enhancements and fixes as detailed in the complete release notes.

YottadB r1.28 is upward compatible with YottaDB r1.26, and thus upward compatible with GT.M V6.3-006 and V6.3-007.

Go Wrapper

As discussed in our blog post YottaDB Go Wrapper on February 6, 2019, we have created a package yottadB to access YottaDB from the Go language, which is among the top 10 in the IEEE Spectrum 2019 language popularity survey. Where we previously considered the Go wrapper to be field test grade, we now consider it to be production grade.

The reason that it takes a YottaDB release to make the Go wrapper production grade arises from the fact that runtime system of the most commonly used Go implementation assumes that it is in primary control of the process. As the YottaDB runtime system resides within the address space of the application process, it must protect its memory from Go. Furthermore, it must install its own signal handlers. Overcoming these hurdles, which in some cases resulted in intermittent failures that caused abnormal process termination sometimes after hours and even days of stress testing on our servers, was in equal measures art and engineering, which prolonged the release date. Our presentation Hidden Dragons of CGO discusses some of these challenges.

On a system or container with YottaDB installed, installing and using the Go wrapper is as simple as:

We are also providing a Dockerfile including the packaged Go wrapper.

Please use the YottaDB Go wrapper, and tell us what you think!

Images Used:
Go Gopher, Renee French.
The design is licensed under the Creative Commons 3.0 Attributions license.
Read this article for more details: https://blog.golang.org/gopher