YottaDBⓇ is a rock solid, lightning fast, and secure database that scales to meet the needs of the very largest, mission critical applications, especially those which need "five nines" availability.
All software in this package is part of YottaDB each file of which identifies its copyright holders. The software is made available to you under the terms of a license. Refer to the COPYING and LICENSE files for details.
YottaDB is a hierarchical key-value database with strongly ACID transactions that does not make you choose between consistency, reliability and performance, even with tens of thousands of concurrent users.
The YottaDB database engine runs in-process, on one node and scales vertically. Its transactions have completely automated retry logic that is included out of the box and optimistic concurrency control for ACID properties, even with tens of thousands of concurrent processes making tens of millions of database accesses, all on a single system.
Because YottaDB runs in-process and scales vertically, it delivers extreme performance that maximizes the throughput of the underlying hardware and operating system.
Unlike most other databases, YottaDB's hierarchical data structure gives you flexibility in your data layer both at the time of the application initial creation as well as throughout the entire lifecycle. Permissions are implemented in the application layer and/or the operating system rather than in the database itself.
YottaDB is used primarily, but not exclusively, in large scale healthcare and financial services applications where data consistency is critical and support from YottaDB LLC provides peace of mind. For example:
- One of the largest banks in Thailand, with 60 million accounts uses YottaDB. While most large banks use a batch system that is updated daily, they have a true real-time system that is able to handle tens of thousands of concurrent users with excellent performance.
- A nation-scale electronic health record system in Jordan uses YottaDB. It uses an open source software stack including YottaDB on Linux for round-the-clock real-time access to medical records for patients and providers in a country of over 10 million people.
See Success Stories for more examples. You do not have to be a large enterprise or a nation-scale application to benefit from YottaDB, but YottaDB will not limit your growth.
The Get Started page gets you started with YottaDB, on your machine, on our virtual machine, or a Docker container. YottaDB provides pre-built binary distributions for current versions of popular Linux distributions (Debian, Red Hat, SUSE, and Ubuntu, as well as selected derivatives), and the ydbinstall.sh script downloads and installs the current release for Supported platforms. Details are on the Get Started page.
Refer to the Release Notes for each release for a list of the Supported platforms on which we build and test YottaDB binary distributions.
On current releases of popular Linux distributions which are Supportable but not Supported (such as Arch Linux and derivatives) the --from-source option of the ydbinstall.sh script downloads, builds, and installs YottaDB. If you are a developer, you can also clone the repository to build and install YottaDB.
git clone https://gitlab.com/YottaDB/DB/YDB.gitydbinstall.sh --help gives you a list of all options. The script also checks for prerequisite packages and utility programs.
YottaDB relies on CMake to generate the Makefiles to build binaries from source. Refer to the Release Notes for each release for a list of the Supported platforms in which we build and test YottaDB binary distributions. At least CMake version 3 is required.
# Debian, Ubuntu and derivatives
sudo apt-get install --no-install-recommends cmake
# Red Hat and derivatives
sudo yum install cmake
# SUSE and derivatives
sudo zypper install cmakeNote: Both gcc and Clang/LLVM are supported on x86_64. To use Clang/LLVM you would need to
install the Clang/LLVM packages for your distribution in addition to the packages
listed below. For example for Ubuntu Linux:
sudo apt-get install --no-install-recommends clang llvm lldDebian, Ubuntu, and derivatives
sudo apt-get install --no-install-recommends file cmake make gawk gcc git curl tcsh libjansson4 {libconfig,libelf,libicu,libncurses,libreadline,libjansson,libssl}-dev binutils ca-certificates
Red Hat and derivatives
sudo yum install file cmake make gawk gcc git curl tcsh jansson {libconfig,libicu,ncurses,elfutils-libelf,readline,jansson,openssl}-devel binutils ca-certificates
SUSE and derivatives
sudo zypper install cmake make gawk gcc git file curl tcsh binutils-gold icu libjansson4 {libconfig,libicu,ncurses,libelf,readline,libjansson,libopenssl}-devel binutils ca-certificatesThere may be other library dependencies or the packages may have different names.
To obtain the source code corresponding to the latest YottaDB release and build binaries from that source please use the following set of shell commands which fetches the latest tagged release by performing a git clone. After cloning YottaDB source files can be seen in the directory named YDB.
ydb_distrib="https://gitlab.com/api/v4/projects/7957109/repository/tags"
ydb_tmpdir='tmpdir'
mkdir $ydb_tmpdir
wget -P $ydb_tmpdir ${ydb_distrib} 2>&1 1>${ydb_tmpdir}/wget_latest.log
ydb_version=`sed 's/,/\n/g' ${ydb_tmpdir}/tags | grep -E "tag_name|.pro.tgz" | grep -B 1 ".pro.tgz" | grep "tag_name" | sort -r | head -1 | cut -d'"' -f6`
git clone --depth 1 --branch $ydb_version https://gitlab.com/YottaDB/DB/YDB.git
cd YDBYou should find this README, LICENSE, COPYING and CMakeLists.txt file and sr_* directories.
Build the YottaDB binaries:
mkdir build
cd buildNote: By default the script creates production (pro) builds of YottaDB. To create
a debug (dbg) build of YottaDB add a -D CMAKE_BUILD_TYPE=Debug parameter to the cmake command.
(Note: title case is important)
cmake ..
export ydb_icu_version=$(pkg-config --modversion icu-io).suse # needed only on SUSE and derivatives
make -j $(getconf _NPROCESSORS_ONLN)
make install
cd yottadb_r* # The latest release number will be seen in the directory nameexport CC=/usr/bin/clang
cmake ..
export ydb_icu_version=$(pkg-config --modversion icu-io).suse # needed only on SUSE and derivatives
make -j $(getconf _NPROCESSORS_ONLN)
make install
cd yottadb_r* # The latest release number will be seen in the directory nameNote that the make install command above does not create the final installed YottaDB.
Instead, it stages YottaDB for distribution.
Now you are ready to install YottaDB. The default installation path for each release includes the release
(e.g. for YottaDB r2.06, the default installation path is /usr/local/lib/yottadb/r206),
but can be controlled using the --installdir option. Run ./ydbinstall --help for a list of options.
Note that if the ydb_icu_version environment variable is set to a value other than what pkg-config --modversion icu-io
would return (observed on a SLED 15 or openSUSE Leap system), then the value of that environment variable needs to be preserved across
the sudo call hence the use of preserve-env below. It is not needed on other systems but does not hurt either.
sudo --preserve-env=ydb_icu_version ./ydbinstall
cd - ; make cleanA working Docker installation on the platform of choice.
NOTE: You must have at least docker 17.05 as multi-stage builds are used within the docker file
The docker image is built using the generic ydb_env_set script that gives the user some sane defaults.
The commands below assume that you want to remove the docker container after running the command, which means that if you don't mount a volume that contains your database and routines they will be lost. If you want the container to persist remove the --rm parameter from the docker command.
Volumes are also supported by mounting to the /data directory. If you want to mount the local directory ydb-data into the container to save your database and routines locally and use them in the container in the future, add the following command line parameter before the yottadb/yottadb argument:
-v $PWD/ydb-data:/data
This creates a ydb-data directory in your current working directory. This can be deleted after the container is shutdown/removed if you want to remove all data created in the YottaDB container (such as your database and routines).
The YottaDB GUI is available on port 9080; statistics for the GUI is running on port 9081.
Pre-built images are available on docker hub
docker run --rm -it -p 9080-9081:9080-9081 download.yottadb.com/yottadb/yottadb # you can add a specific version after a ":" if desired
-
Build the image
docker build -t yottadb/yottadb:latest-master . -
Run the created image
docker run --rm -it -p 9080-9081:9080-9081 yottadb/yottadb:latest-master
To contribute or help with further development, fork the repository, clone your fork to a local copy, and submit Merge Requests! Please also set up the pre-commit and pre-rebase scripts to automatically enforce some coding conventions. Assuming you are in the top-level directory, the following will work:
ln -s ../../pre-commit .git/hooks
ln -s ../../pre-rebase .git/hooksYottaDB is a registered trademark and wordmark of YottaDB LLC. If you use, or distribute, a binary version built from unmodified YottaDB source code, you may refer to that software as YottaDB as long as you acknowledge the trademark / wordmark. If you modify the source code in any way, you may not refer to it as YottaDB unless you have explicit written permission to do so from YottaDB LLC.