Update version to v2.0.2

bindings.go

@@ -412,6 +412,44 @@ func (db *Reindexer) deleteQuery(q *Query) (int, error) {
 	return rawQueryParams.count, err
 }
 
+// Execute query
+func (db *Reindexer) updateQuery(q *Query) (int, error) {
+
+	ns, err := db.getNS(q.Namespace)
+	if err != nil {
+		return 0, err
+	}
+
+	result, err := db.binding.UpdateQuery(ns.nsHash, q.ser.Bytes())
+	if err != nil {
+		return 0, err
+	}
+	defer result.Free()
+
+	ser := newSerializer(result.GetBuf())
+	// skip total count
+	rawQueryParams := ser.readRawQueryParams()
+
+	ns.cacheLock.Lock()
+	for i := 0; i < rawQueryParams.count; i++ {
+		params := ser.readRawtItemParams()
+		if (rawQueryParams.flags&bindings.ResultsWithJoined) != 0 && ser.GetVarUInt() != 0 {
+			panic("Internal error: joined items in update query result")
+		}
+		// Update cache
+		if _, ok := ns.cacheItems[params.id]; ok {
+			delete(ns.cacheItems, params.id)
+		}
+
+	}
+	ns.cacheLock.Unlock()
+	if !ser.Eof() {
+		panic("Internal error: data after end of update query result")
+	}
+
+	return rawQueryParams.count, err
+}
+
 func (db *Reindexer) resetCaches() {
 	db.lock.RLock()
 	nsArray := make([]*reindexerNamespace, 0, len(db.ns))

bindings/builtin/builtin.go

@@ -310,6 +310,14 @@ func (binding *Builtin) DeleteQuery(nsHash int, data []byte) (bindings.RawBuffer
 	return ret2go(C.reindexer_delete_query(binding.rx, buf2c(data)))
 }
 
+func (binding *Builtin) UpdateQuery(nsHash int, data []byte) (bindings.RawBuffer, error) {
+	if binding.cgoLimiter != nil {
+		binding.cgoLimiter <- struct{}{}
+		defer func() { <-binding.cgoLimiter }()
+	}
+	return ret2go(C.reindexer_update_query(binding.rx, buf2c(data)))
+}
+
 func (binding *Builtin) Commit(namespace string) error {
 	return err2go(C.reindexer_commit(binding.rx, str2c(namespace)))
 }

bindings/builtinserver/builtinserver.go

@@ -201,6 +201,10 @@ func (server *BuiltinServer) DeleteQuery(nsHash int, rawQuery []byte) (bindings.
 	return server.builtin.DeleteQuery(nsHash, rawQuery)
 }
 
+func (server *BuiltinServer) UpdateQuery(nsHash int, rawQuery []byte) (bindings.RawBuffer, error) {
+	return server.builtin.UpdateQuery(nsHash, rawQuery)
+}
+
 func (server *BuiltinServer) Commit(namespace string) error {
 	return server.builtin.Commit(namespace)
 }

bindings/consts.go

@@ -63,6 +63,7 @@ const (
 	QueryEnd            = 11
 	QueryExplain        = 12
 	QueryEqualPosition  = 13
+	QueryUpdateField    = 14
 
 	LeftJoin    = 0
 	InnerJoin   = 1

bindings/cproto/connection.go

@@ -35,13 +35,14 @@ const (
 	cmdEnumNamespaces   = 22
 	cmdDropIndex        = 24
 	cmdUpdateIndex      = 25
-	сmdStartTransaction = 25
-	сmdAddTxItem        = 26
-	сmdCommitTx         = 27
-	сmdRollbackTx       = 28
+	cmdAddTxItem        = 26
+	cmdCommitTx         = 27
+	cmdRollbackTx       = 28
+	cmdStartTransaction = 29
 	cmdCommit           = 32
 	cmdModifyItem       = 33
 	cmdDeleteQuery      = 34
+	cmdUpdateQuery      = 35
 	cmdSelect           = 48
 	cmdSelectSQL        = 49
 	cmdFetchResults     = 50

bindings/cproto/cproto.go

@@ -76,7 +76,7 @@ func (binding *NetCProto) Ping() error {
 }
 
 func (binding *NetCProto) BeginTx(namespace string) (ctx bindings.TxCtx, err error) {
-	buf, err := binding.rpcCall(opWr, сmdStartTransaction, namespace)
+	buf, err := binding.rpcCall(opWr, cmdStartTransaction, namespace)
 
 	if len(buf.args) == 0 {
 		return
@@ -89,7 +89,7 @@ func (binding *NetCProto) BeginTx(namespace string) (ctx bindings.TxCtx, err err
 func (binding *NetCProto) CommitTx(ctx *bindings.TxCtx) (bindings.RawBuffer, error) {
 	netBuffer := ctx.Result.(*NetBuffer)
 
-	txBuf, err := netBuffer.conn.rpcCall(сmdCommitTx, int64(ctx.Id))
+	txBuf, err := netBuffer.conn.rpcCall(cmdCommitTx, int64(ctx.Id))
 
 	defer txBuf.Free()
 	defer netBuffer.close()
@@ -108,7 +108,7 @@ func (binding *NetCProto) CommitTx(ctx *bindings.TxCtx) (bindings.RawBuffer, err
 func (binding *NetCProto) RollbackTx(ctx *bindings.TxCtx) error {
 	netBuffer := ctx.Result.(*NetBuffer)
 
-	txBuf, err := netBuffer.conn.rpcCall(сmdRollbackTx, int64(ctx.Id))
+	txBuf, err := netBuffer.conn.rpcCall(cmdRollbackTx, int64(ctx.Id))
 
 	defer txBuf.Free()
 	defer netBuffer.Free()
@@ -137,7 +137,7 @@ func (binding *NetCProto) ModifyItemTx(txCtx *bindings.TxCtx, format int, data [
 
 	netBuffer := txCtx.Result.(*NetBuffer)
 
-	txBuf, err := netBuffer.conn.rpcCall(сmdAddTxItem, format, data, mode, packedPercepts, stateToken, int64(txCtx.Id))
+	txBuf, err := netBuffer.conn.rpcCall(cmdAddTxItem, format, data, mode, packedPercepts, stateToken, int64(txCtx.Id))
 
 	defer txBuf.Free()
 	if err != nil {
@@ -291,6 +291,16 @@ func (binding *NetCProto) DeleteQuery(nsHash int, data []byte) (bindings.RawBuff
 	return buf, nil
 }
 
+func (binding *NetCProto) UpdateQuery(nsHash int, data []byte) (bindings.RawBuffer, error) {
+	buf, err := binding.rpcCall(opWr, cmdUpdateQuery, data)
+	if err != nil {
+		buf.Free()
+		return nil, err
+	}
+	buf.result = buf.args[0].([]byte)
+	return buf, nil
+}
+
 func (binding *NetCProto) Commit(namespace string) error {
 	return binding.rpcCallNoResults(opWr, cmdCommit, namespace)
 }

bindings/interface.go

@@ -130,6 +130,7 @@ type RawBinding interface {
 	Select(query string, withItems bool, ptVersions []int32, fetchCount int) (RawBuffer, error)
 	SelectQuery(rawQuery []byte, withItems bool, ptVersions []int32, fetchCount int) (RawBuffer, error)
 	DeleteQuery(nsHash int, rawQuery []byte) (RawBuffer, error)
+	UpdateQuery(nsHash int, rawQuery []byte) (RawBuffer, error)
 	Commit(namespace string) error
 	EnableLogger(logger Logger)
 	DisableLogger()

changelog.md

@@ -1,3 +1,36 @@
+# Version 2.0.2 (08.03.2019)
+
+## Core 
+- [fea] Update fields of documents, with SQL `UPDATE` statement support
+- [fea] Add SQL query suggestions
+- [fea] Add `DISTINCT` support to SQL query
+- [fea] Queries to non nullable indexes with NULL condition will return error
+- [fix] Fixes of full text search, raised on incremental index build
+- [fix] Queries with forced sort order can return wrong sequences
+- [fix] RPC client&replicator multithread races
+- [fix] DISTINCT condition to store indexes
+- [fix] Caches crash on too fast data invalidation
+- [fix] Disable execiton of delete query from namespace in slave mode
+- [fix] Rebuild fulltext index if configuration changed
+- [fix] Fixed handling SQL numeric conditions values with extra leading 0
+
+# Golang connector
+- [fea] `Query.Update` method added
+- [doc] Updated documentation and mapping for system Namespaces struct
+- [fix] Support of POD types derived custom types
+- [fix] Added `MATCH` condition support (alias `EQ`) to DSL
+
+# Reindexer server
+- [fix] Report error if config file is not found
+
+# Reindexer tool
+- [fea] Add `UPDATE` statement support
+
+# Face
+- [fea] Add SQL query suggest
+- [fea] GUI for database configuration
+- [fea] GUI and charts for performance and memory statistics
+
 # Version 2.0.0 (07.01.2019) 
 
 ## Core

cjson/creflect.go

@@ -242,7 +242,34 @@ func (pl *payloadIface) getArray(field int, startIdx int, cnt int, v reflect.Val
 				(*a)[i] = bool(pi[i] != 0)
 			}
 		default:
-			panic(fmt.Errorf("Can't set []int to []%s", v.Type().Elem().Kind().String()))
+			slice := reflect.MakeSlice(v.Type(), cnt, cnt)
+			switch v.Type().Elem().Kind() {
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+				for i := 0; i < cnt; i++ {
+					sv := slice.Index(i)
+					if sv.Type().Kind() == reflect.Ptr {
+						el := reflect.New(reflect.New(sv.Type().Elem()).Elem().Type())
+						el.Elem().SetUint(uint64(pu[i]))
+						sv.Set(el)
+					} else {
+						sv.SetUint(uint64(pu[i]))
+					}
+				}
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				for i := 0; i < cnt; i++ {
+					sv := slice.Index(i)
+					if sv.Type().Kind() == reflect.Ptr {
+						el := reflect.New(reflect.New(sv.Type().Elem()).Elem().Type())
+						el.Elem().SetInt(int64(pi[i]))
+						sv.Set(el)
+					} else {
+						sv.SetInt(int64(pi[i]))
+					}
+				}
+			default:
+				panic(fmt.Errorf("Can't set []int to []%s", v.Type().Elem().Kind().String()))
+			}
+			v.Set(slice)
 		}
 	case valueInt64:
 		switch a := v.Addr().Interface().(type) {
@@ -267,7 +294,36 @@ func (pl *payloadIface) getArray(field int, startIdx int, cnt int, v reflect.Val
 				(*a)[i] = uint(pi[i])
 			}
 		default:
-			panic(fmt.Errorf("Can't set []int64 to []%s", v.Type().Elem().Kind().String()))
+			slice := reflect.MakeSlice(v.Type(), cnt, cnt)
+			switch v.Type().Elem().Kind() {
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+				pi := (*[1 << 27]uint64)(ptr)[:l:l]
+				for i := 0; i < cnt; i++ {
+					sv := slice.Index(i)
+					if sv.Type().Kind() == reflect.Ptr {
+						el := reflect.New(reflect.New(sv.Type().Elem()).Elem().Type())
+						el.Elem().SetUint(uint64(pi[i]))
+						sv.Set(el)
+					} else {
+						sv.SetUint(uint64(pi[i]))
+					}
+				}
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				pi := (*[1 << 27]int64)(ptr)[:l:l]
+				for i := 0; i < cnt; i++ {
+					sv := slice.Index(i)
+					if sv.Type().Kind() == reflect.Ptr {
+						el := reflect.New(reflect.New(sv.Type().Elem()).Elem().Type())
+						el.Elem().SetInt(int64(pi[i]))
+						sv.Set(el)
+					} else {
+						sv.SetInt(int64(pi[i]))
+					}
+				}
+			default:
+				panic(fmt.Errorf("Can't set []int64 to []%s", v.Type().Elem().Kind().String()))
+			}
+			v.Set(slice)
 		}
 	case valueDouble:
 		pi := (*[1 << 27]Cdouble)(ptr)[:l:l]
@@ -283,13 +339,39 @@ func (pl *payloadIface) getArray(field int, startIdx int, cnt int, v reflect.Val
 				(*a)[i] = float32(pi[i])
 			}
 		default:
-			panic(fmt.Errorf("Can't set []double to []%s", v.Type().Elem().Kind().String()))
+			slice := reflect.MakeSlice(v.Type(), cnt, cnt)
+			for i := 0; i < cnt; i++ {
+				sv := slice.Index(i)
+				if sv.Type().Kind() == reflect.Ptr {
+					el := reflect.New(reflect.New(sv.Type().Elem()).Elem().Type())
+					el.Elem().SetFloat(float64(pi[i]))
+					sv.Set(el)
+				} else {
+					sv.SetFloat(float64(pi[i]))
+				}
+			}
+			v.Set(slice)
 		}
 	case valueString:
-		a := v.Addr().Interface().(*[]string)
-		*a = make([]string, cnt, cnt)
-		for i := 0; i < cnt; i++ {
-			(*a)[i] = pl.getString(field, i+startIdx)
+		if a, ok := v.Addr().Interface().(*[]string); ok {
+			*a = make([]string, cnt, cnt)
+			for i := 0; i < cnt; i++ {
+				(*a)[i] = pl.getString(field, i+startIdx)
+			}
+		} else {
+			slice := reflect.MakeSlice(v.Type(), cnt, cnt)
+			for i := 0; i < cnt; i++ {
+				s := pl.getString(field, i+startIdx)
+				sv := slice.Index(i)
+				if sv.Type().Kind() == reflect.Ptr {
+					el := reflect.New(reflect.New(sv.Type().Elem()).Elem().Type())
+					el.Elem().SetString(s)
+					sv.Set(el)
+				} else {
+					sv.SetString(s)
+				}
+			}
+			v.Set(slice)
 		}
 	}
 }