ultradb

KO | EN

gitlite — search

#javascript #python #hacktoberfest #react #ai #typescript #llm #go #golang #android #machine-learning #rust #deep-learning #linux

★ 9 Open GitHub ↗

Probably* the fastest node database in the world, blazing simple, uses nodejs n-api interface

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# UltraDb
Probably the fastest node database in the world, blazing simple, uses nodejs n-api interface, designed to work in node clusters. It is also very low level database, so inappropriate handling might lead to data corruption. Read documentation carefully before you use it.

Works on 64 bit linux platforms. Other platforms not tested.

# What for is this another database?

Some examples of usage:
 * logging data
 * storing sessions, large numger of documents
 * building custom database data structures (trees, chain lists, ...)
 * microservices
 * services
 * storing training data of ai, ann, ... storing trained results...
 * building more advanced databases with ultradb as their backend
 * everywhere where you need document ID without additional querying for it (you receive document ID always as a result of adding document to database)

It:
 * is small - arround 300kB
 * is written in C for node js intentionally - it is not a wrapper, or port of another database
 * is multicore processors friendly - scales up with node processes, multiple node instances/forks can work simultaneously on same database file
 * is pretty simple and straight forward - not intended to hide any kind of abstraction from you
 * supports text, integers, floats and data buffers
 * supports cursors that allows to iterate through documents starting from newest and allows paging
 * is VERY FAST, try it on SSD drive, compare with other databases, tell me the results - I'm sure you'll be pleased when you'll compare it with other databases for node js
 * is Binary JSON (BSON) and other binary formats friendly

If performance and/or costs of your infrastructure is for you a key factor you should consider use of Ultra DB. It is simple to use library, but requires little more attention from developer and more extensive testing, since there is not much control over what you do with database (for example there is no guarantee that database will trigger an error when trying to update document with non existing ID within a range of IDs in database, more over it might corrupt database). But in return you get a database, that runs within node process (no extra process, no extra overheads for TCP/IP stack, no waisteless copying data, no parsing queries, no switching to additional db tasks, no callbacks and promisses overheads ... and so on). With very little effort you can make pretty advanced services serving many thousands requests a second on a single cheap VPS machine.

# Help highly appreciated! :-)

Feel free to drop a line of code, write tests, prepare documentation, tutorials, guidelines, come up with ideas and so on!

# Important notes

It is unsafe to allow access to documents by their id from any kind of public api (unless all documents are fixed size and you control modulo of document ID). In case of public API additional step of document id validation should be taken (combining document ID and random key saved in the document as public document ID, accessing via another fixed size documents lookup database, hashing id or hasing id combined with kind of checksum ... and so on). Current API profides set of document ID checksum functions (8 - 32 bit) and unique key for checksums for each database file - this will be helpfull to prevent accessing non existing documents.

If document id's are used internally only and you have full control of how are they used, then you don't have to worry about above.

If you need full ACID database you have to design data and recovery mechanisms yourself. But if you only add new records and read them, you're safe, you might consider this database kinda of ACID in that case.

If you're going to use db in nodejs cluster make sure you use transactions where it needs to be synchronized across processes.

Since transactions are blocking other processes that want to use particular database file/files it is a good idea to split data to databases for different document types each.

Newly added documents are hidden till their content is filled into a database.

64 bit integers currently are actually limited to 53 bits. This is due javascript limitation for numbers, not database itself.

Before you start, check examples located in "tests" directory on github repo:
https://github.com/DanielMazurkiewicz/ultradb/tree/master/tests

# Database file structure

```
<header> <document1 data> <document1 length> ... <documentN data> <documentN length>
```

Document ID points indirectly to address of most significant byte of document length. Most significant byte contains additional 3 bit information:
 * most significant bit if set to 1 means that document is hidden
 * second and third most significant bit encodes document length field size:
    - 00 : 1 byte
    - 01 : 2 bytes
    - 10 : 4 bytes
    - 11 : 8 bytes

Since Document ID is indirect address it is technically possible to remove phisically documents from the beginning of database while keeping same Document IDs.

# Usage

## Load database library

```
const UltraDB = require('ultradb');
```

## Open database

```
const testDb = UltraDB('./myDatabase.udb');

```

This will open database.

```
const test1Db = UltraDB('./myDatabase.udb, 2048');

```

This will open database with specified page size, default is 16384. Page size has an impact on performance, the bigger the better performance. The best if it is multiplication of expected average document size.

## Close database

```
testDb.close();
```

Database doesn't require to be closed so in most of cases you can skip this, however, if you're going to open dynamically a lot of databases it is good practice to close the ones you're not using any more.

## Add document (utf8 string with zero at its end)

```
const documentId = testDb.addUtf8z("My frirst ultradb document");
```

This will add new document to database, and if successfull, it will return its id;

## Get document (utf8 string with zero at its end)

```
const documentContent = testDb.getUtf8z(documentId);
```

This will retrieve document from database.

If document is hidden it will return "null"

If document doesn't exist it will return "undefined"

Note that "documentId" parameter is examined only briefly, so providing appropriate value is on your responsibility. Providing inappropriate value might lead to strange behaviour.

Note that it is your responsibility to use appropriate method to read appropriate data type, database doesn't encode document type.

## Default documents data format

```
const testDb = UltraDB('./dbTestCursor.udb').default('Utf8z');
```

Adds shorten names for methods containing given default string. For above example:
```
const documentId = testDb.add('some document');
```
will be equivalent to
```
const documentId = testDb.addUtf8z('some document');
```

Method returns current database instance

## Checking if database contains documents

```
testDb.isEmpty();
```
Returns true if database is empty

## Getting lattest added document identifier

```
const documentId = testDb.last();
```
It returns "undefined" if there is no documents in database.
This method skips all hidden documents. If you need to get latest document, including hidden ones use:
```
const documentId = testDb.lastOfAll();
```

## Getting previously added document identifier

```
const previousDocumentId = testDb.previous(documentId);
```
It returns "undefined" if there is no previous document to given one
This method skips all hidden documents. If you need to get previous document, including hidden ones use:
```
const previousDocumentId = testDb.previousOfAll(documentId);
```

Example: Iterate through all documents
```
for (let id = testDb.last(); id != undefined; id = testDb.previous(id)) {
  console.log(testDb.get(id));
}
```

Note that "documentId" parameter is examined only briefly, so providing appropriate value is on your responsibility. Providing inappropriate value might lead to strange behaviour.

## Rolling database

```
testDb.roll();
```

Writes new documents from begining of database file (with a guarantee of assigning non existing yet new document id's for new documents). It replaces oldest added documents in database.

## Hiding document

```
testDb.hide(documentId);
```

Note that "documentId" parameter is examined only briefly, so providing appropriate value is on your responsibility. Providing inappropriate value might lead to strange behaviour or database corruption.

## Unhiding document

```
testDb.unhide(documentId);
```

## Database access synchronization

```
testDb.start();

//code that needs to be run exclusively on database so other processes have to wait

testDb.stop();
```

Method "start" informs that transaction has started, and method "stop" informs that transaction has ended.

Note that simple adding new documents to database and reading them is process safe, so there is no need to use transactions. Same if your node application is single process accessing particular database.

### Multiple databases synchronization

```
const testDb1 = UltraDb('./testdb1.udb');
const testDb2 = UltraDb('./testdb2.udb');
const testDb3 = UltraDb('./testdb3.udb');
const multiTransaction123 = UltraDB.prepareMultiTransaction(testDb1, testDb2, testDb3);

// ...

UltraDB.start(multiTransaction123);

//code that needs to be run exclusively on given set of databases

UltraDB.stop(multiTransaction123);
```

Using this methods prevents cross transaction lock while transaction on multiple databases.

# Full API list

(methods with skipped description simply have same functionality as previously described, but on different size of data)

## Document
### docAddHidden(documentSize)
creates empty hidden document and returns documentInfo reference

### docAdd(documentSize)
creates empty document and returns documentInfo reference

### docGet(documentId)
returns documentInfo reference for given documentId

### docGetHiddenAndVisible(documentId)
returns documentInfo reference for given documentId for both, visible and hidden documents

### docGetId(documentInfo)
returns id of document based on given documentInfo reference

## Document ID obsfucation
### docIdGenerateKey(bits, rounds, randomData)
creates key which is a Buffer type containing instructions for encrypting/decrypting documentID, bits defines expected maximum size of documentID (6-64 bits), rounds defines ciphering complexity - the higher number the harder to crack (0 gives the weakest ciphering), randomData - at least 64 bytes of random buffer data has to be provided in order to be able to generate key - the more rounds the more data should be provided (approximatly each round should have additional 24 bytes of random data)

### docIdEncrypt(documentId, key)
encrypts given documentId with given key, returns Number which is a ciphered representation of documentId

### docIdDecrypt(encryptedDocumentId, key)
decrypts given encryptedDocumentID with given key, returns Number which is decrypted documentID

## Database info and management
### isEmpty()
returns true if database is empty

### roll()
rolls database, new documents will replace oldest documents in database

### setRoot(documentId)
allows to set top level document if someone need a document with some kind of settings, or keeping any kind of structures where entry document is required

### getRoot()
retrieves id of current root document

## Document ID operations - 32 bit
### docIdVerify32(documentInfo, offset_within_document)
validates 32 bit checksum of document ID, provided indirectly by documentInfo, at given position

### docIdCheckSet32(documentInfo, offset_within_document)
sets 32 bit checksum for document provided by documentInfo reference, checksum is set at given position, but it is recommended for checksum not to be last element in the document.

## Document ID operations - 16 bit
### docIdVerify16(documentInfo, offset_within_document)
### docIdCheckSet16(documentInfo, offset_within_document)

## Document ID operations - 8 bit
### docIdVerify8(documentInfo, offset_within_document)
### docIdCheckSet8(documentInfo, offset_within_document)

## Data operations - buffer in Buffer format
### addBuffer(buffer, length)
adds new document with given buffer, returns id of created document, if length is -1 adds entire buffer, otherwise adds begining number of bytes from buffer and if length is bigger than buffer length, rest of space is left empty

### addBufferFixed(buffer, length, length_of_document)
adds new document with given buffer, document is fixed length, remaining space after buffer is empty, writes only as many bytes as provided in "length" property (if -1 writes all of them, if bigger then length of buffer, then writes as much as available and rest remains empty), returns id of created document

### getBuffer(documentId, length)
returns to buffer "length" number of bytes of document with given id, if length is -1 then reads all of document content

### setBuffer(documentId, buffer, length)
sets/replaces buffer of document with given id, length points how many bytes to write (if -1 writes all of them, if bigger then length of buffer, then writes as much as available and rest remains unchanged)

### addBufferAt(buffer, length, offset_within_document)
creates document with buffer and leaves begining of document empty, returns newly created document id, length points how many bytes to write (if -1 writes all of them, if bigger then length of buffer, then writes as much as available and rest remains empty)

### addBufferFixedAt(buffer, length, length_of_document, offset_within_document)
creates document with buffer placed in the middle of document, document is fixed size, returns newly created document id, length points how many bytes to write (if -1 writes all of them, if bigger then length of buffer, then writes as much as available and rest remains empty)

### getBufferAt(documentId, length, offset_within_document)
returns buffer of document with given id at given position, if length is -1 then reads all content from given offset position

### setBufferAt(documentId, buffer, length, offset_within_document)
sets/replaces buffer placed in the middle of document, length points how many bytes to write (if -1 writes all of them, if bigger then length of buffer, then writes as much as available and rest remains unchanged)

### partGetBuffer(documentInfo, length, offset_within_document)
returns buffer located at given position in document based on given documentInfo (see "Document API"), if length is -1 then reads all content from given offset position

### partSetBuffer(documentInfo, buffer, length, offset_within_document)
sets/replaces buffer located at given position in document based on given documentInfo, length points how many bytes to write (if -1 writes all of them, if bigger then length of buffer, then writes as much as available and rest remains unchanged)

## Data operations - text in Utf8z format
### addUtf8z(text)
adds new document with given text, returns id of created document

### addUtf8zFixed(text, text_length_max, length_of_document)
adds new document with given text, checks if it fits given maximum length fot text in utf8 format, document is fixed length, remaining space after text is empty. returns id of created document

### getUtf8z(documentId)
returns text of document with given id

### setUtf8z(documentId, text)
sets/replaces text of document with given id

### addUtf8zAt(text, offset_within_document)
creates document with text and leaves begining of document empty, returns newly created document id

### addUtf8zFixedAt(text, text_length_max, length_of_document, offset_within_document)
creates document with text placed in the middle of document, document is fixed size, returns newly created document id

### getUtf8zAt(documentId, offset_within_document)
returns text of document with given id at given position

### setUtf8zAt(documentId, text, text_length_max, offset_within_document)
sets/replaces text placed in the middle of document

### partGetUtf8z(documentInfo, offset_within_document)
returns text located at given position in document based on given documentInfo (see "Document API")

### partSetUtf8z(documentInfo, text, text_length_max, offset_within_document)
sets/replaces text located at given position in document based on given documentInfo (see "Document API"), validates if it fits maximum length

## Data operations - 64 bit float numbers
### addF64(number)
adds new document with given number, returns id of created document

### addF64Fixed(number, length_of_document)
adds new document with given number, document is fixed length, remaining space after number is empty. returns id of created document

### getF64(documentId)
returns number of document with given id

### setF64(documentId, number)
sets/replaces number of document with given id

### addF64At(number, offset_within_document)
creates document with number and leaves begining of document empty, returns newly created document id

### addF64FixedAt(number, length_of_document, offset_within_document)
creates document with number placed in the middle of document, document is fixed size, returns newly created document id

### getF64At(documentId, offset_within_document)
returns number of document with given id at given position

### setF64At(documentId, number, offset_within_document)
sets/replaces number placed in the middle of document

### partGetF64(documentInfo, offset_within_document)
returns number located at given position in document based on given documentInfo (see "Document API")

### partSetF64(documentInfo, number, offset_within_document)
sets/replaces number located at given position in document based on given documentInfo (see "Document API")

## Data operations - 32 bit float numbers
### addF32(number)
### addF32Fixed(number, length_of_document)
### getF32(documentId)
### setF32(documentId, number)
### addF32At(number, offset_within_document)
### addF32FixedAt(number, length_of_document, offset_within_document)
### getF32At(documentId, offset_within_document)
### setF32At(documentId, number, offset_within_document)
### partGetF32(documentInfo, offset_within_document)
### partSetF32(documentInfo, number, offset_within_document)

## Data operations - 64 bit unsigned integer numbers
### addU64(number)
### addU64Fixed(number, length_of_document)
### getU64(documentId)
### setU64(documentId, number)
### addU64At(number, offset_within_document)
### addU64FixedAt(number, length_of_document, offset_within_document)
### getU64At(documentId, offset_within_document)
### setU64At(documentId, number, offset_within_document)
### partGetU64(documentInfo, offset_within_document)
### partSetU64(documentInfo, number, offset_within_document)

## Data operations - 48 bit unsigned integer numbers
### addU48(number)
### addU48Fixed(number, length_of_document)
### getU48(documentId)
### setU48(documentId, number)
### addU48At(number, offset_within_document)
### addU48FixedAt(number, length_of_document, offset_within_document)
### getU48At(documentId, offset_within_document)
### setU48At(documentId, number, offset_within_document)
### partGetU48(documentInfo, offset_within_document)
### partSetU48(documentInfo, number, offset_within_document)

## Data operations - 32 bit unsigned integer numbers
### addU32(number)
### addU32Fixed(number, length_of_document)
### getU32(documentId)
### setU32(documentId, number)
### addU32At(number, offset_within_document)
### addU32FixedAt(number, length_of_document, offset_within_document)
### getU32At(documentId, offset_within_document)
### setU32At(documentId, number, offset_within_document)
### partGetU32(documentInfo, offset_within_document)
### partSetU32(documentInfo, number, offset_within_document)

## Data operations - 24 bit unsigned integer numbers
### addU24(number)
### addU24Fixed(number, length_of_document)
### getU24(documentId)
### setU24(documentId, number)
### addU24At(number, offset_within_document)
### addU24FixedAt(number, length_of_document, offset_within_document)
### getU24At(documentId, offset_within_document)
### setU24At(documentId, number, offset_within_document)
### partGetU24(documentInfo, offset_within_document)
### partSetU24(documentInfo, number, offset_within_document)

## Data operations - 16 bit unsigned integer numbers
### addU16(number)
### addU16Fixed(number, length_of_document)
### getU16(documentId)
### setU16(documentId, number)
### addU16At(number, offset_within_document)
### addU16FixedAt(number, length_of_document, offset_within_document)
### getU16At(documentId, offset_within_document)
### setU16At(documentId, number, offset_within_document)
### partGetU16(documentInfo, offset_within_document)
### partSetU16(documentInfo, number, offset_within_document)

## Data operations - 8 bit unsigned integer numbers
### addU8(number)
### addU8Fixed(number, length_of_document)
### getU8(documentId)
### setU8(documentId, number)
### addU8At(number, offset_within_document)
### addU8FixedAt(number, length_of_document, offset_within_document)
### getU8At(documentId, offset_within_document)
### setU8At(documentId, number, offset_within_document)
### partGetU8(documentInfo, offset_within_document)
### partSetU8(documentInfo, number, offset_within_document)

## Data operations - 64 bit signed integer numbers
### addS64(number)
### addS64Fixed(number, length_of_document)
### getS64(documentId)
### setS64(documentId, number)
### addS64At(number, offset_within_document)
### addS64FixedAt(number, length_of_document, offset_within_document)
### getS64At(documentId, offset_within_document)
### setS64At(documentId, number, offset_within_document)
### partGetS64(documentInfo, offset_within_document)
### partSetS64(documentInfo, number, offset_within_document)

## Data operations - 48 bit signed integer numbers
### addS48(number)
### addS48Fixed(number, length_of_document)
### getS48(documentId)
### setS48(documentId, number)
### addS48At(number, offset_within_document)
### addS48FixedAt(number, length_of_document, offset_within_document)
### getS48At(documentId, offset_within_document)
### setS48At(documentId, number, offset_within_document)
### partGetS48(documentInfo, offset_within_document)
### partSetS48(documentInfo, number, offset_within_document)

## Data operations - 32 bit signed integer numbers
### addS32(number)
### addS32Fixed(number, length_of_document)
### getS32(documentId)
### setS32(documentId, number)
### addS32At(number, offset_within_document)
### addS32FixedAt(number, length_of_document, offset_within_document)
### getS32At(documentId, offset_within_document)
### setS32At(documentId, number, offset_within_document)
### partGetS32(documentInfo, offset_within_document)
### partSetS32(documentInfo, number, offset_within_document)

## Data operations - 24 bit signed integer numbers
### addS24(number)
### addS24Fixed(number, length_of_document)
### getS24(documentId)
### setS24(documentId, number)
### addS24At(number, offset_within_document)
### addS24FixedAt(number, length_of_document, offset_within_document)
### getS24At(documentId, offset_within_document)
### setS24At(documentId, number, offset_within_document)
### partGetS24(documentInfo, offset_within_document)
### partSetS24(documentInfo, number, offset_within_document)

## Data operations - 16 bit signed integer numbers
### addS16(number)
### addS16Fixed(number, length_of_document)
### getS16(documentId)
### setS16(documentId, number)
### addS16At(number, offset_within_document)
### addS16FixedAt(number, length_of_document, offset_within_document)
### getS16At(documentId, offset_within_document)
### setS16At(documentId, number, offset_within_document)
### partGetS16(documentInfo, offset_within_document)
### partSetS16(documentInfo, number, offset_within_document)

## Data operations - 8 bit signed integer numbers
### addS8(number)
### addS8Fixed(number, length_of_document)
### getS8(documentId)
### setS8(documentId, number)
### addS8At(number, offset_within_document)
### addS8FixedAt(number, length_of_document, offset_within_document)
### getS8At(documentId, offset_within_document)
### setS8At(documentId, number, offset_within_document)
### partGetS8(documentInfo, offset_within_document)
### partSetS8(documentInfo, number, offset_within_document)

# Android termux prerequisites:

```
pkg install python2
pkg install make
pkg install clang
```

Currently not working on Android due to Androids lack of support for sys/shm. :(

ultradb

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README