The change set includes:
1) A header file that contains the Major, Minor, and Patch versions of speedb
as a macro, as well as a set of functions returning info about how/when/where
this version of speedb was created.

also includes all changes done on build_version.cc.in in the following commits:
1. version: remove superfluous build property
The `speedb_build_spdb_key` property is unused and was accidentally
imported as part of #1.

2.general: replace RocksDB references in strings with Speedb (#64)
This includes references in statuses as well as tools output.

as changes to it are either
version updates or fixing compiler errors.

combination of seek random and overwrite random.
all threads are doing seek and write interchangeably.

They were made because the original version failed to compile with Clang
12 and 13, complaining about `offsetof()` being applied to a non-standard-layout
type. The error is no longer emitted with Clang 14, so this is likely a
compiler bug that was fixed, and there's no need for this dirty hack.

…s status code

This breaks when comparing against e.g. `Status::NoSpace()` because it has
a status code of `Code::kIOError` and only a subcode of `SubCode::kNoSpace`.

…status code

This breaks in cases such as `Status::NoSpace()`, which has a status code
of `Code::kIOError`, and a subcode of `SubCode::kNoSpace`, but the comparison
ends up checking only if a general IO error happened.

The example acquires snapshots but doesn't release them, resulting in a
memory leak error when run under ASan.

test doesnt delete db properly.

fix both these tests to operate not only on the default cf

Clang 14 fails to compile with the following error:

```
options/db_options.h:120:21: error: definition of implicit copy constructor for 'MutableDBOptions' is deprecated because it has a user-declared copy assignment operator [-Werror,-Wdeprecated-copy]
  MutableDBOptions& operator=(const MutableDBOptions&) = default;
                    ^
db/compaction/compaction_job.cc:439:7: note: in implicit copy constructor for 'rocksdb::MutableDBOptions' first required here
      mutable_db_options_copy_(mutable_db_options),
      ^
```

This is caused by the introduction of an assignment operator in #7 due to
a diagnostic emitted by Clang 13 which isn't emitted by Clang 14, so this
was probably a compiler bug, and we just need to remove the assignment
operator.

This is relevant for not including the delay in latency calculation, and
is already done for the write rate limiter.

Made use of the CreateFromString to pass an arbitrary URI to create a memtable factory to the tools that use it.

…on (#80)

The new Customizable plugin infra in CMake relies on regex parsing of
Makefiles, which is very brittle and clunky, as well as being unintuitive
for CMake users.

The only thing missing from the old infra is plugin `*_FUNC` registration,
so just add support for that to the old infra, and remove the Makefile
parsing logic.

This memtable supports concurrent readers and writers and provides much
better results for insertions and point selections than the skip list
memtable, while maintaining more tolerable iteration performance than the
built-in RocksDB hash-based memtable.

This allows us to make sure that our additions are included
in the build even if the user forgot to set `ROCKSDB_PLUGINS`
explicitly.

Currently only the skip list memtable is being tested. Increase
coverage by adding the new Speedb memtable as an option as well.
For now we'll simply choose randomly between the two, without
giving any one of them preference, but we may want to change that
in the future.

A last minute change before merging #30 breaks builds that configure
`-Werror=unused-parameter` (this is the default for some GCC versions
with the `-Wextra` configuration).

Fix it by not declaring the `logger` argument to the `CreateMemTableRep()`
function.

As part of #90, I accidentally added a comma at the end of the
line when choosing the memtable reperesntation to use. This is
a tuple construction syntax and was formatted as such by Black,
but unfortunately missed by me and during review.

Fix it by removing the comma so that the argument isn't passed
to db_stress as a Python tuple.

The test seems to fail for now, so in order to avoid headaches for devs
working on `main`, let's not test the new memtable until the issues are
fixed. This is not intended as a fix for #98, but rather as a temporary
workaround to allow testing to continue, since no one is supposed to be
using the new memtable yet.

Devops ci/add build tools (#104)

new release line network hotfix (#109)

The tests that break are `env_test` and `db_test`.

`env_test` fails due to trying to use `FS_IOC_GETVERSION` on an overlayfs,
which doesn't support it. We need to use a host filesystem for this because
only certain filesytsems support this ioctl. For this we add a host bind
volume to /var/tmp which is what the code tries to use.

`db_test` fails for an unknown reason and only in buffered I/O mode, which
might indicate a bug in overlayfs. This is caused by a setting of the `TMPD`
environment variable to the overlayfs mount. Add a mount to the host's /tmp
directory and set `TMPD` to it instead (we can't use the default of /dev/shm
because there's not enough memory available on the runner machines).

While at it, clean up the workflow definition a bit.

* docs: initial contribution guide update

This includes changes to building instructions, in order to reflect our
level of commitment to platform support and to change references to RocksDB
with Speedb.

* moar updates

* Update README.md

Co-authored-by: Arthur Berezin <[email protected]>

The test target in the Java Makefile has an incorrect dependency graph
that could cause tests to start executing before the compilation finished
(or even started) when make is invoked in job server mode.

Fix it by specifying target dependencies such that running the tests depends
on having the tests compiled first.

…#126)

Rolling back in these cases is meaningless because the memtables will be
freed shortly afterwards, so making them available for flush again is useless
at best.

Additionally, in atomic flush, memtables that were successfully flushed
aren't rolled back if a CF is dropped or a DB shutdown was requested (the
shutdown case is the more relevant one for the comparison here because it
aborts the flush, whereas the in the CF drop case it's simply ignored at
flush result installation time). In this regard this change simply matches
the behaviour there.

Lastly, this might be needed for the WriteBufferManager changes in #113,
since we plan to use the information about memory that can be flushed in
the future for triggering flushes based on immutable memory as well, and
rolling back flushes causes the memtable memory to become ready for flush
again for a brief period of time until it is dropped, which might wrongly
affect the WBM decisions.

When compiling bloom_test with GCC 12 it complains about using uninitialised
variables. The error is technically wrong, since only the address is taken,
but since this is a test and there's no performance penalty, initialise
the member to get rid of the error.

Remove dependency on perl, which isn't really needed and can be replaced
with POSIX tools. Also do some minor cleanup of the check targets.

This allows using more up to date versions from the user's system as well
as possibly patched versions with additional features.

We only license Speedb under the Apache 2.0 licence, so we need to remove
the GPL text from the repository. Since GNU Parallel is currently
vendored in the repo and requires having a copy of the GPL text, remove
it as well and depend on the system installed binary if exists (out build
instructions ask users to install it anyway, and it's installed in CI).

Update license files to comply with Apache 2.0 and update authors

* Adding logo and badges to readme

Move the definition of the fuzz testing jobs to a separate workflow
so that it could be reused by workflows other than the main CI one.

Allow plugins to compile and run their unit tests as part of the
Speedb build and test runs.

The changes in #119 included an upstream commit that moved the TEST_TMPDIR
setting to common.mk and executed it unconditionally.

This is causing pollution of /dev/shm unnecessarily, and also causes the
crash tests and other targets to use /dev/shm when they originally didn't.
On machines with small /dev/shm this leads to the crash tests failing with
an out of space error.

Make the setting of TEST_TMPDIR and the creation of a temporary directory
under it execute only once during a single make invocation and only for
the check target, as it was originally. This requires dealing with make
restarts (due to makefiles getting remade) in the form of adding another
temporary configuration file named test_config.mk

The debugging backup logic in whitebox wasn't cleaning up DB copies on
timeout because the cleanup logic was inside the loop. Move it to the end
of the function to ensure that backups are cleaned up on success.

Also make sure to clean up DB backup copies in the narrow test.

Following the change of scheduling purges with low priority, instead of high priority,
tests that tried to block purges from happening by taking up
a slot in the high priority queue, had to instead be scheduled with low piority too.

This would allow us to compare the performance of changes related to
background purges using db_bench.

Shell tab-completions are currently broken due to the regeneration of
`make_config.mk` on every invocation, which also causes a make restart.

Prevent regeneration if the file exists and we're in an invocation that
doesn't execute rule recipes (-n or -q).

After the changes in #141, parallel `make check` started failing with the
following GNU Parallel error:

> Option tmpdir requires an argument

This is caused by the fact that `test_config.mk` uses `?=` for setting
`TEST_TMPDIR` and on make restarts this doesn't work for some reason
(perhaps having to do with empty `TEST_TMPDIR` being somehow exported).

Replace it with a check for empty value and unconditional assignment
instead. While at it, include `test_config.mk` only on make restarts for
check targets instead of forcing everything that makes use of `TEST_TMPDIR`
to reuse the unit tests configuration.

Also use 6 Xs for the mktemp template in order to support BusyBox mktemp
and maybe some others as well, that require the template to end with 6 Xs
exactly.

Add the Speedb release notes to the HISTORY file.

Allow running tests in parallel by default by setting the CTEST_PARALLEL_LEVEL
environment variable. The functionality is added using a CMake script in
order to determine options when running the tests (rather than when configuring
CMake) in compatibility with the Makefile (in particular -- the `J` and
`TEST_TMPDIR` environment variables).

While at it, add a test timeout parameter in order to kill stuck tests,
and set the default timeout to 10 minutes (we don't currently have tests
that are running longer than that).

Test Plan: run the check target using different generators (ninja, make)
to see the improvement in test runtime.

)

The Makefile has many places where it needlessly invokes a sub-make instead
of declaring the dependencies correctly. Rework the dependency graph so
that at least running tests doesn't involve invoking make three times.

This also avoids pollution in /dev/shm caused by the needless creation of
temporary directories on make restarts and sub-make invocations.

since purges are now set from the LOW pri pool,
the bg job scheduled when background_purge_on_iterator_cleanup is
true is scheduled in the compaction queue

This is done through the deprecated `max_background_compactions` option,
which overrides `max_background_jobs`, so in order to avoid having an
adverse effect on users who set `max_background_jobs` to a high value
we try to detect that case and shift back to the user's choice in case
there are enough background jobs to be enough for both flushes and
compactions.

In #194 the default value for background compaction threads was changed
to 8 (from 1). This caused some tests to fail, but they were fixed. Alas,
the fixes seems to not be complete, as under stress some tests still fail.

Make it so the tests are truly fixed now. This can be checked by running
them in a loop with the machine overloaded:

```
$ while ./db_compaction_test --gtest_filter=DBCompactionTestWithParam/DBCompactionTestWithParam.PartialCompactionFailure/1; do sleep 1; done
```

And

```
$ while ./deletefile_test --gtest_filter=DeleteFileTest.BackgroundPurgeCopyOptions; do sleep 1; done
```

The paired Bloom filter files are either missing a copyright notice and
licence header, or contain the wrong one. Fix that in order to adhere
to the contribution guidelines.

This updates the CMake and Makefile configuration and related scripts to
use variables where possible and avoid explicit references to RocksDB in
order to allow rebranding of the output artefacts.

This includes both the CMake and Makefile configurations, various scripts
that are invoked during the build or during test runs, as well as the
Java native library loader code.

This includes simple renaming from `rocksdb` to `speedb` as well as replacing
URLs that are pointing to the RocksDB repository with the URL of the Speedb
repository.

This includes references in statuses as well as tools output.

This is done across all tools except trace_replay, which specifically
looks for the RocksDB version for database compatibility checks.

The release pipeline is currently editing the RocksDB version and in a
broken manner. Fix it and use a proper trigger for the artefacts release.

In the case where we create the test path, we should clean up after the
run finishes as done in the Makefile, due to garbage that is left behind
by tests and accumulates.

While at it, randomise test scheduling in order to increase the likelihood
of surfacing latent bugs that are hidden by the execution order.

The build tag can be set during the build (using either the Makefile
or the CMake). If it's not provided, and we're not in a release build,
it will be calculated using the state of the git tree since the last
release tag (for example, for this PR the build tag will be calculated as
`(main+17)-(156-build-add-a-build-tag-into-the-version-for-non-release-builds+1)`.

If the git tree state can not be determined, a question mark will be
used instead.

Add support for detecting and using ccache/sccache to the Makefile build
in order to speed up build times as it's done in the CMake configuration.

This is a continuation of #126 with changes that were missed there in case
a CF drop was encountered after the flush was completed but before or during
manifest write.

Rolling back on CF drop is meaningless because a flush is not possible
in that state, and the only path forwards is for the memtables to be freed
shortly afterwards, so making them available for flush again is useless
at best.

Additionally, this might be needed for the WriteBufferManager changes in
in the future for triggering flushes based on immutable memory as well,
and rolling back flushes causes the memtable memory to become ready for
flush again for a brief period of time until it is dropped, which might
wrongly affect the WBM decisions.

Finally, the code installs a new version even if no changes are made. This
is unnecessary and as such that part is moved into the version-mutating
code path only.

This PR also adds two regression tests, so we could rely on rollback not
being performed on CF drop.

…#217)

In #194 the default value for background compaction threads was changed
to 8 (from 1). This caused some tests to fail and fixes were implemented
as part of #197. Alas, it seems that the fixes weren't complete, as under
stress a test still fail.

Make it so the test is truly fixed now. This can be verified by running
them in a loop with the machine overloaded:

```
$ while ./deletefile_test --gtest_filter=DeleteFileTest.BackgroundPurgeCFDropTest; do sleep 1; done
```

Both were incorrectly referencing the old artefact names before the
changes in #66.

Specify `SPDB_RELEASE_BUILD` to both CMake and the Makefile builds in order
to get the release artefacts to build without a build tag of `?`.

)

Merge commits were incorrectly handled due to the named use of `git rev-list`,
which does not give an ancestry path as I expected, but simply a list of
unique commits between the two refs.

Additionally, the check for the base tag was wrong in the face of merge
commits, since a tag could be an ancestor through a merge commit, but not
be the actual base of the branch.

Both of these issues resulted in an incorrect tag being calculated, as well
as a build slowdown due to the iteration over all of the commits from the
other parent of the merge commit, which is unneeded.

While at it, add logic for caching the build tag in order to speed up
builds when the checked-out git tree hasn't changed.

fix by adding WaitUntilSleeping before deleting the iterator

…234)

Import shorten memtable switch latency (#14)