Update to version v5.12.0

Author: MadSchemas

bindings/builtinserver/builtinserver.go

@@ -49,6 +49,9 @@ type BuiltinServer struct {
 }
 
 func (server *BuiltinServer) stopServer(timeout time.Duration) error {
+	if server.svc == 0 {
+		return nil
+	}
 	if err := err2go(C.stop_reindexer_server(server.svc)); err != nil {
 		return err
 	}
@@ -276,6 +279,7 @@ func (server *BuiltinServer) Finalize() error {
 		return err
 	}
 	C.destroy_reindexer_server(server.svc)
+	server.svc = 0
 	server.builtin = nil
 	server.shutdownTimeout = 0
 	return nil

bindings/consts.go

@@ -2,7 +2,7 @@ package bindings
 
 const CInt32Max = int(^uint32(0) >> 1)
 
-const ReindexerVersion = "v5.11.1"
+const ReindexerVersion = "v5.12.0"
 
 // public go consts from type_consts.h and reindexer_ctypes.h
 const (
@@ -40,6 +40,7 @@ const (
 	CollateCustom  = 4
 
 	FunctionFlatArrayLen = 0
+	FunctionNow          = 1
 )
 
 // private go consts from type_consts.h and reindexer_ctypes.h
@@ -97,6 +98,12 @@ const (
 	QueryKnnConditionExt           = 33
 	QueryFunction                  = 34
 	QueryFunctionSubQueryCondition = 35
+	QueryExpressions               = 36
+
+	ExpressionTypeField      = 0
+	ExpressionTypeValues     = 1
+	ExpressionTypeExpression = 2
+	ExpressionTypeSubQuery   = 3
 
 	KnnQueryTypeBase       = 0
 	KnnQueryTypeBruteForce = 1

bindings/interface.go

@@ -87,17 +87,24 @@ type EmbeddingConfig struct {
 	// Query embedder configuration
 	QueryEmbedder *EmbedderConfig `json:"query_embedder,omitempty"`
 }
+type QuantizationConfig struct {
+	Type       string  `json:"quantization_type"`
+	Quantile   float32 `json:"quantile,omitempty"`
+	SampleSize int64   `json:"sample_size,omitempty"`
+	Threshold  int64   `json:"quantization_threshold,omitempty"`
+}
 
 type FloatVectorIndexOpts struct {
-	Metric             string           `json:"metric"`
-	Dimension          int              `json:"dimension"`
-	M                  int              `json:"m,omitempty"`
-	EfConstruction     int              `json:"ef_construction,omitempty"`
-	StartSize          int              `json:"start_size,omitempty"`
-	CentroidsCount     int              `json:"centroids_count,omitempty"`
-	MultithreadingMode int              `json:"multithreading,omitempty"`
-	Radius             float32          `json:"radius,omitempty"`
-	EmbeddingConfig    *EmbeddingConfig `json:"embedding,omitempty"`
+	Metric             string              `json:"metric"`
+	Dimension          int                 `json:"dimension"`
+	M                  int                 `json:"m,omitempty"`
+	EfConstruction     int                 `json:"ef_construction,omitempty"`
+	StartSize          int                 `json:"start_size,omitempty"`
+	CentroidsCount     int                 `json:"centroids_count,omitempty"`
+	MultithreadingMode int                 `json:"multithreading,omitempty"`
+	Radius             float32             `json:"radius,omitempty"`
+	EmbeddingConfig    *EmbeddingConfig    `json:"embedding,omitempty"`
+	QuantizationConfig *QuantizationConfig `json:"quantization_config,omitempty"`
 }
 
 type IndexDef struct {

changelog.md

@@ -1,3 +1,43 @@
+# Version 5.12.0 (20.03.2026)
+## Core
+- [fea] Added [now()-function](readme.md#nowunit) support into `WHERE`-clause. Now it may be used both in `UPDATE SET` and `WHERE` clauses
+- [fea] Added [flat_array_len()-function](readme.md#flat_array_lenfield_name) into `UPDATE SET`. Now it may be used both in `UPDATE SET` and `WHERE` clauses
+- [fea] Added `checksum` field into `#memstats`-namespaces as better alternative for `datahash`
+- [fea] Changed [grouping logic for equal_position](readme.md#search-in-array-fields-with-matching-indexes-using-grouping). New syntax/logic has better match with standard json-paths and also supports nested arrays in explicit way
+- [fix] Fixed possible memory leak during `composite`-indexes substitution inside WHERE-clauses (in cases, when `int`->`string` convertion was performed before `composite` substitution)
+- [fix] Fixed SQL parsing for queries with combination of `or inner join(...)` and `left join(...)`
+- [fix] Fixed storage data migration, when Primary key index was changed
+- [fix] Fixed `2D points` convertion on WHERE-clause (perviously it could led to crashes on assertion)
+- [fix] Added explicit check for `rtree` Primary keys. [Geo-indexes](readme.md#geometry) can not be PK anymore
+- [fix] Fixed [forced sort](readme.md#forced-sort) errors handling for [KNN-queries](float_vector.md), when query has `LIMIT` and `OFFSET`
+- [fix] Fixed `UUID`->`string` conversions for nested arrays on `UUID`-index deletion
+
+## Fulltext
+- [fea] Added [optional terms boost](fulltext.md#base-config-parameters), that allows to set rank multiplier for specific terms
+
+## Vector indexes
+- [fea] Added 8 bit scalar quantization for HNSW-index. [Read more...](float_vector.md#quantization-configuration-for-hnsw-index)
+- [fea] Added more effective vectorized implementations for `L2`, `IP` and `cosine` metrics.
+
+## Replication
+- [fea] Added `checksum` check instead of `datahash` - `checksum` implementation has lower collisions rate and higher impact from each document's field
+- [fix] Fixed some rare case, when `temporary` namespace could remain alive after replication error
+
+## Reindexer server
+- [fea] Changed [FilterDef](https://github.com/Restream/reindexer/blob/v5.12.0/cpp_src/server/contrib/server.yml#L4161) in Query DSL: some of the fields were marked as deprecated and `left_expression`/`right_expression` were as more unified alternatives for better [functions](readme.md#functions) support and future filtering expressions development
+
+## Go connector
+- [fea] Added unified `WhereExpressions` method for better [functions](readme.md#functions) support and future filtering expressions development
+- [fix] Fixed deserialization crash for queries, where `inner join` stays before [equal_position](readme.md#search-in-array-fields-with-matching-indexes) in brackets
+
+## Face
+- [fea] Added `Explain` visualization for queries with [MERGE](fulltext.md#merging-queries-results)
+- [fea] Added `Boost for specific fulltext terms` into fulltext config tab
+- [fix] Fixed up/down buttons for custom field on pagination section
+- [fix] Fixed the issue related to the page opening in a new window from left bar
+- [fix] Fixed the issue related to the page opening in a new window from `Namespace` tabs
+- [fix] Fixed `Explain` table in `Query Builder`
+
 # Version 5.11.1 (05.03.2026)
 ## Fulltext
 - [fix] Fixed possible heap-use-after in composite fulltext indexes, created over non-indexed fields

cjson/creflect.go

@@ -17,6 +17,7 @@ const (
 	valueUuid        = bindings.ValueUuid
 	valueFloatVector = bindings.ValueFloatVector
 	valueFloat       = bindings.ValueFloat
+	valueTuple       = bindings.ValueTuple
 )
 
 const (

cjson/serializer.go

@@ -4,6 +4,7 @@ import (
 	"encoding/binary"
 	"fmt"
 	"math"
+	"reflect"
 	"unsafe"
 
 	"sync"
@@ -117,6 +118,65 @@ func (s *Serializer) PutDouble(v float64) *Serializer {
 	return s
 }
 
+func (s *Serializer) PutValue(v reflect.Value) error {
+	k := v.Kind()
+	if k == reflect.Ptr || k == reflect.Interface {
+		v = v.Elem()
+		k = v.Kind()
+	}
+	switch k {
+	case reflect.Bool:
+		s.PutVarCUInt(valueBool)
+		if v.Bool() {
+			s.PutVarUInt(1)
+		} else {
+			s.PutVarUInt(0)
+		}
+	case reflect.Uint:
+		if unsafe.Sizeof(int(0)) == unsafe.Sizeof(int64(0)) {
+			s.PutVarCUInt(valueInt64)
+		} else {
+			s.PutVarCUInt(valueInt)
+		}
+
+		s.PutVarInt(int64(v.Uint()))
+	case reflect.Int:
+		if unsafe.Sizeof(int(0)) == unsafe.Sizeof(int64(0)) {
+			s.PutVarCUInt(valueInt64)
+		} else {
+			s.PutVarCUInt(valueInt)
+		}
+		s.PutVarInt(v.Int())
+	case reflect.Int16, reflect.Int32, reflect.Int8:
+		s.PutVarCUInt(valueInt)
+		s.PutVarInt(v.Int())
+	case reflect.Uint8, reflect.Uint16, reflect.Uint32:
+		s.PutVarCUInt(valueInt)
+		s.PutVarInt(int64(v.Uint()))
+	case reflect.Int64:
+		s.PutVarCUInt(valueInt64)
+		s.PutVarInt(v.Int())
+	case reflect.Uint64:
+		s.PutVarCUInt(valueInt64)
+		s.PutVarInt(int64(v.Uint()))
+	case reflect.String:
+		s.PutVarCUInt(valueString)
+		s.PutVString(v.String())
+	case reflect.Float32, reflect.Float64:
+		s.PutVarCUInt(valueDouble)
+		s.PutDouble(v.Float())
+	case reflect.Slice, reflect.Array:
+		s.PutVarCUInt(valueTuple)
+		s.PutVarCUInt(v.Len())
+		for i := 0; i < v.Len(); i++ {
+			s.PutValue(v.Index(i))
+		}
+	default:
+		panic(fmt.Errorf("rq: Invalid reflection type %s", v.Kind().String()))
+	}
+	return nil
+}
+
 func (s *Serializer) writeIntBits(v int64, sz uintptr) {
 	l := len(s.buf)
 	s.grow(int(sz))

clang-tidy/.clang-tidy

@@ -2,6 +2,7 @@ Checks: 'clang-diagnostic-*,
          clang-analyzer-*,
          performance-*,
          bugprone-*,
+         rx-*,
          -bugprone-branch-clone,
          -bugprone-easily-swappable-parameters,
          -bugprone-macro-parentheses,
@@ -13,6 +14,9 @@ Checks: 'clang-diagnostic-*,
          -bugprone-parent-virtual-call,
          -bugprone-integer-division,
          -bugprone-inc-dec-in-conditions,
+         -bugprone-std-namespace-modification,
+         -bugprone-throwing-static-initialization,
+         -bugprone-derived-method-shadowing-base-method,
          -clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling,
          -performance-no-int-to-ptr,
          -performance-enum-size,
@@ -21,6 +25,8 @@ Checks: 'clang-diagnostic-*,
 # clang-analyzer-security.insecureAPI.DeprecatedOrUnsafeBufferHandling - too many unnecessary warning in vendored code
 # performance-no-int-to-ptr - consider how to fix this
 # bugprone-macro-parentheses - consider fixing
+# bugprone-std-namespace-modification - we have a lot of std::hash/operator>>. Consider fixing
+# bugprone-throwing-static-initialization - seems irrelevant
 WarningsAsErrors: '*'
 HeaderFilterRegex: '.*/cpp_src/([^v]|v[^e]|ve[^n]|ven[^d]|vend[^o]|vendo[^r]).*$'
 FormatStyle:     none

clang-tidy/custom_checks/CMakeLists.txt

@@ -0,0 +1,40 @@
+cmake_minimum_required(VERSION 3.18)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(TARGET custom-tidy-checks)
+project(${TARGET})
+
+find_package(LLVM REQUIRED CONFIG)
+find_package(Clang REQUIRED CONFIG)
+
+message(STATUS "LLVM found: ${LLVM_DIR}")
+message(STATUS "Clang found: ${Clang_DIR}")
+
+add_definitions(${LLVM_DEFINITIONS})
+include_directories(${LLVM_INCLUDE_DIRS})
+include_directories(${CLANG_INCLUDE_DIRS})
+include_directories(${PROJECT_SOURCE_DIR}/src)
+
+file (
+  GLOB_RECURSE
+  SRCS
+  ${PROJECT_SOURCE_DIR}/src/*
+)
+
+add_library(${TARGET} MODULE ${SRCS})
+
+target_link_libraries(${TARGET}
+    clangTidy
+    clangTidyMain
+    clangASTMatchers
+    clangAST
+    clangBasic
+    LLVMSupport
+)
+
+set_target_properties(${TARGET} PROPERTIES
+    PREFIX ""
+    SUFFIX ".so"
+)

clang-tidy/custom_checks/src/lambda_check.cc

@@ -0,0 +1,61 @@
+#include <clang/AST/ASTContext.h>
+#include <clang/AST/DeclCXX.h>
+#include <clang/AST/ExprCXX.h>
+#include <clang/AST/Type.h>
+#include <clang/ASTMatchers/ASTMatchers.h>
+#include <clang/Basic/Diagnostic.h>
+#include <clang/Basic/SourceLocation.h>
+
+#include "lambda_check.h"
+
+using namespace clang;
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace reindexer_checks {
+
+void LambdaToStdFunctionAllocationCheck::registerMatchers(MatchFinder* Finder) {
+	// Match the constructor call of std::function that takes exactly one argument
+	// whose type (after stripping references) is a lambda closure type.
+	auto LambdaType = qualType(hasCanonicalType(hasDeclaration(cxxRecordDecl(isLambda()))));
+	auto StdFunctionCtor =
+		cxxConstructExpr(hasDeclaration(cxxConstructorDecl(ofClass(classTemplateSpecializationDecl(hasName("::std::function"))))),
+						 argumentCountIs(1), hasArgument(0, hasType(qualType(LambdaType))))
+			.bind("ctor");
+
+	Finder->addMatcher(StdFunctionCtor, this);
+}
+
+void LambdaToStdFunctionAllocationCheck::check(const MatchFinder::MatchResult& Result) {
+	const auto* Ctor = Result.Nodes.getNodeAs<CXXConstructExpr>("ctor");
+	if (!Ctor) {
+		return;
+	}
+
+	// Get the type of the lambda argument.
+	const Expr* Arg = Ctor->getArg(0);
+	QualType ArgType = Arg->getType();
+
+	// Strip references and cv-qualifiers to get the underlying lambda type.
+	ArgType = ArgType.getCanonicalType().getNonReferenceType().getUnqualifiedType();
+
+	const auto* RD = ArgType->getAsCXXRecordDecl();
+	if (!RD || !RD->isLambda()) {
+		return;
+	}
+
+	// Compute the size of the lambda closure type in bytes.
+	ASTContext& Ctx = *Result.Context;
+	uint64_t Size = Ctx.getTypeSize(ArgType) / 8;  // bits → bytes
+
+	const unsigned Threshold = 16;
+	if (Size > Threshold) {
+		diag(Ctor->getBeginLoc(), "lambda capture size is %0 bytes (>%1), converting to std::function may allocate memory dynamically")
+			<< Size << Threshold;
+	}
+}
+
+}  // namespace reindexer_checks
+}  // namespace tidy
+}  // namespace clang

clang-tidy/custom_checks/src/lambda_check.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <clang-tidy/ClangTidy.h>
+#include <clang-tidy/ClangTidyCheck.h>
+#include <clang/ASTMatchers/ASTMatchFinder.h>
+
+namespace clang {
+namespace tidy {
+
+namespace reindexer_checks {
+
+class LambdaToStdFunctionAllocationCheck : public ClangTidyCheck {
+public:
+	LambdaToStdFunctionAllocationCheck(StringRef Name, ClangTidyContext* Context) : ClangTidyCheck(Name, Context) {}
+	void registerMatchers(::clang::ast_matchers::MatchFinder* Finder) override;
+	void check(const ::clang::ast_matchers::MatchFinder::MatchResult& Result) override;
+};
+
+}  // namespace reindexer_checks
+}  // namespace tidy
+}  // namespace clang