An Embeddable NoSQL Database Engine

Star

Follow @symisc

Tweet

Follow @unqlite_db

The following page enumerates distinctive features of the UnQLite Database Engine and the Jx9 Embedded Scripting Language.

Feature of the UnQLite Database Engine

• Serverless, NoSQL database engine.

• Transactional (ACID) database.

• Zero configuration.

• Single database file, does not use temporary files.

• Cross-platform file format.

• UnQLite is a Self-Contained C library without dependency.

• Standard Key/Value store.

• Document store (JSON) database via Jx9.

• Support cursors for linear records traversal.

• Pluggable run-time interchangeable storage engine.

• Support for on-disk as well in-memory databases.

• Built with a powerful disk storage engine which support O(1) lookup.

• Thread safe and full reentrant.
• Simple, Clean and easy to use API.
• Support Terabyte sized databases.
  
• JSON documents are stored on disk using the fastJSON format.
  

• Very high code quality, written in ANSI C, compile and run unmodified in most platforms including restricted embedded devices with a C compiler.

• BSD licensed product.

• Amalgamation: All C source code for UnQLite and Jx9 are combined into a single source file.

• Highly available online support.

Feature of the jx9 Embedded Scripting Language

• Turing complete programming language based on JSON.
• Clean and familiar syntax similar to C and JavaScript.
• Dynamically typed programming language.

• Highly efficient bytecode compiler.

• Native support for Anonymous functions.
• Function overloading like C++.
• Full type hinting.

• 64-bit integer arithmetic.

• Native UTF-8 support.

• Built with over 50 operators.
• Comma expressions.
• Support for static variables and constants.
• Rich standard library built with over 312 functions and 143 constants.

• Easy to bind C/C++ foreign functions as well foreign constants.
  

• Highly efficient and platform independent Bytecode compiler.

• Built-in HTTP Request Parser.

• Efficient implementation of JSON arrays and objects using the hashmap data strcuture.

• No fatal error, even a call to an undefined function will not abort Jx9 script execution.

• Jx9 is 100% hand-coded (No Lex, flex, YACC, Lemon, etc.), written in ANSI C, compile and run unmodified in any platform including restricted embedded devices with a C compiler.

• Garbage Collected via Advanced Reference Counting.

• Tiny memory footprint.
• and many more, refer to the Jx9 Programming Language Reference Manual for additional information.

Interested in Machine Learning & Computer Vision? try out Pixlab

We describe now, some of the important UnQLite features in details.

Transactional (ACID) database

A transactional database is one in which all changes and queries appear to be Atomic, Consistent, Isolated, and Durable (ACID). Like SQLite, UnQLite implements serializable transactions that are atomic, consistent, isolated, and durable, even if the transaction is interrupted by a program crash, an operating system crash, or a power failure to the computer.

Serverless database Engine

Most NoSQL database engines (i.e. MongoDB, Redis, CouchDB) are implemented as a separate server process. Programs that want to access the database communicate with the server using some kind of interprocess communication (typically TCP/IP) to send requests to the server and to receive back results. UnQLite like SQLite does not work this way. With UnQLite, the process that wants to access the database reads and writes directly from the database files on disk. There is no intermediary server process.

Zero-Configuration Database Engine

UnQLite does not need to be "installed" before it is used. There is no "setup" procedure. There is no server process that needs to be started, stopped, or configured. There is no need for an administrator to create a new database instance or assign access permissions to users. UnQLite uses no configuration files. Nothing needs to be done to tell the system that UnQLite is running. No actions are required to recover after a system crash or power failure. There is nothing to troubleshoot.

Single Database File

A UnQLite database is a single ordinary disk file that can be located anywhere in the directory hierarchy. If UnQLite can read the disk file then it can read anything in the database. If the disk file and its directory are writable, then UnQLite can change anything in the database. Database files can easily be copied onto a USB memory stick or emailed for sharing.

Cross-Platform File Format

The UnQLite file format is cross-platform. A database file written on one machine can be copied to and used on a different machine with a different architecture. Big-endian or little-endian, 32-bit or 64-bit does not matter. All machines use the same file format.

Standard Key/Value Store Database

UnQLite is a standard key/value store similar to BerkeleyDB, Tokyo Cabinet, LevelDB, etc. but, with a rich feature set including support for transactions (ACID). Under the KV store, both keys and values are treated as simple arrays of bytes, so content can be anything from ASCII strings, binary blob and even disk files. The KV store layer is presented to host applications via a set of interfaces, these includes: unqlite_kv_store(), unqlite_kv_append(), unqlite_kv_fetch_callback(), unqlite_kv_append_fmt(), unqlite_kv_delete(), etc.

Self-Contained Library

UnQLite is a self-contained C library without dependency. It requires very minimal support from external libraries or from the operating system. This makes it well suited for use in embedded devices that lack the support infrastructure of a desktop computer. This also makes UnQLite appropriate for use within applications that need to run without modification on a wide variety of computers of varying configurations.

Pluggable Run-time Interchangeable Storage Engine

UnQLite works with run-time interchangeable storage engines (i.e. Hash, B+Tree, R+Tree, LSM, etc.). The storage engine works with key/value pairs where both the key and the value are byte arrays of arbitrary length and with no restrictions on content. UnQLite come with two built-in KV storage engine: A Virtual Linear Hash (VLH) storage engine is used for persistent on-disk databases with O(1) lookup time and an in-memory hash-table or Red-black tree storage engine is used for in-memory databases. Future versions of UnQLite might add other built-in storage engines (i.e. LSM).