github.com/siglens/siglens@v0.0.0-20240328180423-f7ce9ae441ed/pkg/querytracker/snhasher.go

/*
Copyright 2023.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package querytracker

import (
	"fmt"
	"sort"
	"strings"

	"github.com/cespare/xxhash"
	"github.com/siglens/siglens/pkg/segment/structs"
	"github.com/siglens/siglens/pkg/segment/utils"
)

/*
	  ALGORITHM for creating a unique hash

	   1. In each struct maintain a hid (hashid), it is pre-determined way of creating hash out of
		  of elements of that struct in the sequence they are defined in the go files
	   2. If a struct has sub-structs then we recursively call the hashid func
	   3. if the hid is already present then we use it else we calculate it for that data type
	   4. we keep doing recursive until we get base data types of go like int, bool, string, etc...
	   5. This is a pretty standard way of creating id borrowed from the java world
*/
func GetHashForQuery(n *structs.SearchNode) string {
	return fmt.Sprintf("%v", getHashForSearchNode(n))
}

func GetHashForAggs(a *structs.QueryAggregators) string {
	return fmt.Sprintf("%v", getHashForAggregators(a))
}

func getHashForAggregators(a *structs.QueryAggregators) uint64 {

	if a == nil {
		return 0
	}

	// the only parts of aggs we need to hash are the groupby configs
	// the bucketing/sorting/early exiting does not change pqs vs not, agileTree vs not
	val := fmt.Sprintf("%v:%v:%v",
		getHashForGroupBy(a.GroupByRequest),
		getHashForSegmentStats(a.MeasureOperations),
		getHashForTimeHistogram(a.TimeHistogram),
	)

	return xxhash.Sum64String(val)
}

func getHashForSearchNode(sn *structs.SearchNode) uint64 {

	if sn == nil {
		return 0
	}

	val := fmt.Sprintf("%v:%v:%v",
		getHashForSearchCondition(sn.AndSearchConditions),
		getHashForSearchCondition(sn.OrSearchConditions),
		getHashForSearchCondition(sn.ExclusionSearchConditions),
	)

	return xxhash.Sum64String(val)
}

func getHashForSearchCondition(sc *structs.SearchCondition) uint64 {

	if sc == nil {
		return 0
	}

	sqhids := make([]uint64, len(sc.SearchQueries))
	for _, sq := range sc.SearchQueries {
		sqhids = append(sqhids, getHashForSearchQuery(sq))
	}
	sort.Slice(sqhids, func(i, j int) bool { return sqhids[i] < sqhids[j] })

	snhids := make([]uint64, len(sc.SearchNode))
	for _, sn := range sc.SearchNode {
		snhids = append(snhids, getHashForSearchNode(sn))
	}
	sort.Slice(snhids, func(i, j int) bool { return snhids[i] < snhids[j] })

	var sb strings.Builder
	for _, entry := range sqhids {
		sb.WriteString(fmt.Sprintf("%v:", entry))
	}

	for _, entry := range snhids {
		sb.WriteString(fmt.Sprintf("%v:", entry))
	}

	return xxhash.Sum64String(sb.String())
}

func getHashForSearchQuery(sq *structs.SearchQuery) uint64 {

	if sq == nil {
		return 0
	}

	val := fmt.Sprintf("%v:%v:%v:%v",
		getHashForSearchExpression(sq.ExpressionFilter),
		getHashForMatchFilter(sq.MatchFilter),
		sq.SearchType,
		getHashForQueryInfo(sq.QueryInfo))
	return xxhash.Sum64String(val)
}

func getHashForSearchExpression(se *structs.SearchExpression) uint64 {

	if se == nil {
		return 0
	}

	val := fmt.Sprintf("%v:%v:%v:%v",
		getHashForSearchExpressionInput(se.LeftSearchInput),
		se.FilterOp,
		getHashForSearchExpressionInput(se.RightSearchInput),
		getHashForSearchInfo(se.SearchInfo))
	return xxhash.Sum64String(val)
}

func getHashForMatchFilter(mf *structs.MatchFilter) uint64 {

	if mf == nil {
		return 0
	}

	mwords := make([]string, len(mf.MatchWords))
	for _, w := range mf.MatchWords {
		mwords = append(mwords, string(w))
	}

	sort.Strings(mwords)

	val := fmt.Sprintf("%v:%v:%v:%v:%v",
		mf.MatchColumn,
		mwords,
		mf.MatchOperator,
		mf.MatchPhrase,
		mf.MatchType)

	return xxhash.Sum64String(val)
}

func getHashForQueryInfo(qi *structs.QueryInfo) uint64 {

	if qi == nil {
		return 0
	}

	val := fmt.Sprintf("%v:%v",
		qi.ColName,
		getHashForDtypeEnclosure(qi.QValDte))

	return xxhash.Sum64String(val)
}

func getHashForSearchInfo(si *structs.SearchInfo) uint64 {

	if si == nil {
		return 0
	}

	val := fmt.Sprintf("%v:%v",
		si.ColEncoding,
		getHashForDtypeEnclosure(si.QValDte))

	return xxhash.Sum64String(val)
}

func getHashForDtypeEnclosure(dte *utils.DtypeEnclosure) uint64 {

	if dte == nil {
		return 0
	}

	var val string
	switch dte.Dtype {
	case utils.SS_DT_BOOL:
		val = fmt.Sprintf("%v:%v", dte.Dtype, dte.BoolVal)
	case utils.SS_DT_STRING:
		val = fmt.Sprintf("%v:%v", dte.Dtype, dte.StringVal)
	case utils.SS_DT_UNSIGNED_NUM:
		val = fmt.Sprintf("%v:%v", dte.Dtype, dte.UnsignedVal)
	case utils.SS_DT_SIGNED_NUM:
		val = fmt.Sprintf("%v:%v", dte.Dtype, dte.SignedVal)
	case utils.SS_DT_FLOAT:
		val = fmt.Sprintf("%v:%v", dte.Dtype, dte.FloatVal)
	}

	return xxhash.Sum64String(val)
}

func getHashForSearchExpressionInput(sei *structs.SearchExpressionInput) uint64 {

	if sei == nil {
		return 0
	}

	val := fmt.Sprintf("%v:%v:%v",
		sei.ColumnName,
		getHashForExpression(sei.ComplexRelation),
		getHashForDtypeEnclosure(sei.ColumnValue))

	return xxhash.Sum64String(val)
}

func getHashForExpression(e *structs.Expression) uint64 {

	if e == nil {
		return 0
	}

	val := fmt.Sprintf("%v:%v:%v",
		getHashForExpressionInput(e.LeftInput),
		e.ExpressionOp,
		getHashForExpressionInput(e.RightInput))

	return xxhash.Sum64String(val)
}

func getHashForExpressionInput(ei *structs.ExpressionInput) uint64 {

	if ei == nil {
		return 0
	}

	val := fmt.Sprintf("%v:%v",
		getHashForDtypeEnclosure(ei.ColumnValue),
		ei.ColumnName)

	return xxhash.Sum64String(val)
}

func getHashForGroupBy(r *structs.GroupByRequest) uint64 {
	if r == nil {
		return 0
	}

	val := fmt.Sprintf("%v:%v",
		getHashForGroupByColumns(r.GroupByColumns),
		getHashForMeasureOperations(r.MeasureOperations))
	return xxhash.Sum64String(val)
}

func getHashForSegmentStats(mOps []*structs.MeasureAggregator) uint64 {
	return getHashForMeasureOperations(mOps)
}

func getHashForTimeHistogram(tb *structs.TimeBucket) uint64 {
	if tb == nil {
		return 0
	}

	var sb strings.Builder
	sb.WriteString(fmt.Sprintf("%v:", tb.EndTime))
	sb.WriteString(fmt.Sprintf("%v:", tb.StartTime))
	sb.WriteString(fmt.Sprintf("%v", tb.IntervalMillis))
	return xxhash.Sum64String(sb.String())
}

func getHashForGroupByColumns(cols []string) uint64 {
	if len(cols) == 0 {
		return 0
	}

	sort.Strings(cols)
	var sb strings.Builder
	for _, entry := range cols {
		sb.WriteString(fmt.Sprintf("%v:", entry))
	}
	return xxhash.Sum64String(sb.String())
}

func getHashForMeasureOperations(measureOps []*structs.MeasureAggregator) uint64 {
	if len(measureOps) == 0 {
		return 0
	}

	temp := make([]string, len(measureOps))
	for idx, m := range measureOps {
		temp[idx] = fmt.Sprintf("%+v-%+v", m.MeasureCol, m.MeasureFunc.String())
	}
	sort.Strings(temp)
	var sb strings.Builder
	for _, entry := range temp {
		sb.WriteString(fmt.Sprintf("%v:", entry))
	}
	return xxhash.Sum64String(sb.String())
}