github.com/siglens/siglens@v0.0.0-20240328180423-f7ce9ae441ed/pkg/segment/structs/segsearchstructs_test.go (about)

     1  /*
     2  Copyright 2023.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package structs
    18  
    19  import (
    20  	"testing"
    21  
    22  	. "github.com/siglens/siglens/pkg/segment/utils"
    23  	log "github.com/sirupsen/logrus"
    24  	"github.com/stretchr/testify/assert"
    25  )
    26  
    27  func Test_getSearchInputFromFilter(t *testing.T) {
    28  
    29  	simpleFilter := &FilterInput{
    30  		SubtreeResult: "literal1",
    31  	}
    32  
    33  	search := getSearchInputFromFilterInput(simpleFilter, 0)
    34  	log.Info(search)
    35  	assert.Equal(t, search.ColumnValue.StringVal, "literal1")
    36  
    37  	expInput := &ExpressionInput{
    38  		ColumnName: "key1",
    39  	}
    40  	exp := &Expression{
    41  		LeftInput: expInput,
    42  	}
    43  	expressionColumnFilter := &FilterInput{
    44  		Expression: exp,
    45  	}
    46  
    47  	search = getSearchInputFromFilterInput(expressionColumnFilter, 0)
    48  	log.Info(search)
    49  	assert.Nil(t, search.ColumnValue)
    50  	assert.Equal(t, 1, len(search.getAllColumnsInSearch()))
    51  	assert.Equal(t, "key1", search.ColumnName)
    52  	assert.Nil(t, search.ComplexRelation)
    53  
    54  	leftExpInput := &ExpressionInput{
    55  		ColumnName: "key1",
    56  	}
    57  	rightExpInput := &ExpressionInput{
    58  		ColumnName: "key2",
    59  	}
    60  	exp = &Expression{
    61  		LeftInput:    leftExpInput,
    62  		ExpressionOp: Add,
    63  		RightInput:   rightExpInput,
    64  	}
    65  	expressionComplexFilter := &FilterInput{
    66  		Expression: exp,
    67  	}
    68  	search = getSearchInputFromFilterInput(expressionComplexFilter, 0)
    69  	assert.Nil(t, search.ColumnValue)
    70  	assert.Equal(t, 0, len(search.ColumnName))
    71  	assert.Equal(t, 2, len(search.getAllColumnsInSearch()))
    72  	assert.NotNil(t, search.ComplexRelation)
    73  }
    74  
    75  func Test_extractBlockBloomTokens(t *testing.T) {
    76  	numLiteral, _ := CreateDtypeEnclosure(1.0, 0)
    77  	leftNumberInput := &SearchExpressionInput{
    78  		ColumnValue: numLiteral,
    79  	}
    80  
    81  	strLiteral, _ := CreateDtypeEnclosure("abc", 0)
    82  	leftLiteralInput := &SearchExpressionInput{
    83  		ColumnValue: strLiteral,
    84  	}
    85  
    86  	strWildcardLiteral, _ := CreateDtypeEnclosure("abc*", 0)
    87  	leftWildCardInput := &SearchExpressionInput{
    88  		ColumnValue: strWildcardLiteral,
    89  	}
    90  
    91  	rightInput := &SearchExpressionInput{
    92  		ColumnName: "col1",
    93  	}
    94  
    95  	query := &SearchQuery{
    96  		ExpressionFilter: &SearchExpression{
    97  			LeftSearchInput:  leftNumberInput,
    98  			FilterOp:         Equals,
    99  			RightSearchInput: rightInput,
   100  		},
   101  	}
   102  	allKeys, wildcard, op := query.GetAllBlockBloomKeysToSearch()
   103  	assert.Len(t, allKeys, 1, "only 1 key")
   104  	_, ok := allKeys["1"]
   105  	assert.True(t, ok, "value exists")
   106  	assert.False(t, wildcard)
   107  	assert.Equal(t, And, op)
   108  
   109  	query.ExpressionFilter.LeftSearchInput = leftLiteralInput
   110  	allKeys, wildcard, op = query.GetAllBlockBloomKeysToSearch()
   111  	assert.Len(t, allKeys, 1, "only 1 key")
   112  	_, ok = allKeys["abc"]
   113  	assert.True(t, ok, "abc key exists")
   114  	assert.False(t, wildcard)
   115  	assert.Equal(t, And, op)
   116  
   117  	query.ExpressionFilter.LeftSearchInput = leftWildCardInput
   118  	allKeys, wildcard, op = query.GetAllBlockBloomKeysToSearch()
   119  	assert.Len(t, allKeys, 0, "no keys")
   120  	_, ok = allKeys["abc*"]
   121  	assert.False(t, ok, "abc* should not exist bc of wildcard")
   122  	assert.True(t, wildcard)
   123  	assert.Equal(t, And, op)
   124  
   125  	matchTest := &SearchQuery{
   126  		MatchFilter: &MatchFilter{
   127  			MatchColumn:   "*",
   128  			MatchWords:    [][]byte{[]byte("a"), []byte("b"), STAR_BYTE},
   129  			MatchOperator: Or,
   130  		},
   131  	}
   132  	allKeys, wildcard, op = matchTest.GetAllBlockBloomKeysToSearch()
   133  	assert.True(t, wildcard)
   134  	assert.Len(t, allKeys, 2, "2 keys")
   135  	_, ok = allKeys["a"]
   136  	assert.True(t, ok, "key a exists")
   137  
   138  	_, ok = allKeys["b"]
   139  	assert.True(t, ok, "key b exists")
   140  
   141  	_, ok = allKeys["*"]
   142  	assert.False(t, ok, "key * does not exists")
   143  	assert.Equal(t, Or, op)
   144  }