reindexer

Installation

Reindexer can run in 3 different modes:

• embedded (builtin) Reindexer is embedded into application as static library, and does not require separate server process.
• embedded with server (builtinserver) Reindexer is embedded into the application as a static library and starts a server. In this mode, other clients can connect to the application via cproto, cprotos, ucproto, http, or https.
• standalone Reindexer runs as a standalone server; the application connects to Reindexer via network or Unix domain sockets.

Installation for server mode

In this mode Reindexer's Go-binding does not depend on reindexer's static library.

1. Install Reindexer Server
2. go get -a github.com/restream/reindexer/v5

Official docker image

The simplest way to get Reindexer server is to pull and run the Docker image from Docker Hub.

docker run -p9088:9088 -p6534:6534 -it reindexer/reindexer

Dockerfile

Installation for embedded mode

Prerequisites

Reindexer's core is written in C++20 and uses LevelDB as the storage backend, so CMake, a C++20 toolchain, and LevelDB must be installed before installing Reindexer. Also, OpenMP and BLAS/LAPACK libraries may be required for full vector index support.

To build Reindexer, g++ 10+, clang 15+, or mingw64 is required.

In embedded mode, Reindexer's Go binding depends on Reindexer's static libraries (core, server, and resource).

Get Reindexer using go.mod

This way is recommended and will fit for the most scenarios.

Go modules with go.mod do not allow to build C++ libraries in modules' directories. Go-binding will use pkg-config to detect libraries' directories.

Reindexer's libraries must be either installed from sources or from prebuilt package via package manager.

Then get the module:

go get -a github.com/restream/reindexer/v5

Get Reindexer using go.mod and replace

If you need modified Reindexer's sources, you can use replace like that.

1. Download and build reindexer:

---

## Events subscription

When reindexer used as caching DB by multiple applications, it may be helpful to subscribe on the database updates (for example, if you need to invalidate internal application cache on some database event):

```go

import events "github.com/restream/reindexer/v5/events"

// Create subscription options for the specific event types (any documents modifications + transactions commits)
opts := events.DefaultEventsStreamOptions().WithDocModifyEvents().WithTransactionCommitEvents()
// Create events stream
stream := db.Subscribe(opts)
if err := stream.Error(); err != nil {
	panic(err)
}
// Stream must be finalized. Finalization here basically means 'unsubscribe'
defer stream.Close(context.Background())

for {
	// Reading events
	event, ok := <- stream.Chan()
	if !ok {
		// Events channel is closed
		fmt.Printf("Reindexer events stream was invalidated: %v\n", stream.Error())
		break
	}
	// Event handling logic
	...
}

Single Go binding supports up to 32 simultaneous streams. All the streams are handled together via separated connection (for cproto) or separated goroutine (for builtin/builtinserver).

In case of critical errors Chan() will be closed automatically. New stream must be created to renew events subscription in this case.

To configure subscription EventsStreamOptions-object should be used. It is possible to subscribe for the specific operations types and namespaces. There are predefined events collections in streamopts.go, but any required types may also be specified via WithEvents-option. With default options events stream will receive all