github.com/siglens/siglens@v0.0.0-20240328180423-f7ce9ae441ed/pkg/es/query/queryparser_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 query 18 19 import ( 20 "strconv" 21 "testing" 22 23 "github.com/siglens/siglens/pkg/config" 24 "github.com/siglens/siglens/pkg/segment/structs" 25 . "github.com/siglens/siglens/pkg/segment/structs" 26 . "github.com/siglens/siglens/pkg/segment/utils" 27 log "github.com/sirupsen/logrus" 28 "github.com/stretchr/testify/assert" 29 ) 30 31 func Test_ParseRequest(t *testing.T) { 32 json_body := []byte(`{ 33 "size": 0, 34 "query":{ 35 "bool": {"must" : 36 {"term" : { "user.id" : "kimchy" }} 37 }}}`) 38 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 39 assert.Nil(t, err) 40 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 41 assert.NotNil(t, res.AndFilterCondition.FilterCriteria) 42 assert.Len(t, res.AndFilterCondition.FilterCriteria, 1) 43 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 44 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "kimchy") 45 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 46 } 47 48 func Test_parseQuery_matchall(t *testing.T) { 49 json_body := []byte(`{ 50 "query": { 51 "match_all": {} 52 } 53 }`) 54 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 55 assert.Nil(t, err) 56 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 57 assert.IsType(t, res, &ASTNode{}) 58 assert.NotNil(t, res.AndFilterCondition.FilterCriteria) 59 assert.Len(t, res.AndFilterCondition.FilterCriteria, 1) 60 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "*") 61 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 62 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "*") 63 } 64 65 func Test_parseQuery_bool(t *testing.T) { 66 json_body := []byte(`{ 67 "bool" :{} 68 }`) 69 _, err := parseBool(json_body, 0, false) 70 assert.NotNil(t, err) 71 } 72 73 func Test_parseQuery_must(t *testing.T) { 74 json_body := []byte(`{ 75 "query":{ 76 "bool": {"must" : 77 {"term" : { "user.id" : "kimchy" }} 78 }}}`) 79 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 80 assert.Nil(t, err) 81 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 82 assert.NotNil(t, res.AndFilterCondition.FilterCriteria) 83 assert.Len(t, res.AndFilterCondition.FilterCriteria, 1) 84 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 85 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "kimchy") 86 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 87 } 88 89 func Test_ParseRequest_must_term_array(t *testing.T) { 90 json_body := []byte(`{ 91 "query":{ 92 "bool": {"must" : 93 [{"term" : { "user.id" : "kimchy" }}, 94 {"term" : { "id" : 123 }} 95 ] 96 }}}`) 97 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 98 assert.Nil(t, err) 99 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 100 assert.NotNil(t, res.AndFilterCondition.FilterCriteria) 101 assert.Len(t, res.AndFilterCondition.FilterCriteria, 2) 102 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 103 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "kimchy") 104 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 105 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "id") 106 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.UnsignedVal, uint64(123)) 107 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].ExpressionFilter.FilterOperator, Equals) 108 } 109 110 func Test_ParseRequest_match_noQueryClause(t *testing.T) { 111 112 json_body := []byte(`{ 113 "query":{ 114 "bool": {"must" : 115 {"match": {"message": "this is a test"}} 116 }}}`) 117 118 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 119 assert.Nil(t, err) 120 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 121 assert.IsType(t, res, &ASTNode{}) 122 assert.NotNil(t, res.AndFilterCondition.FilterCriteria) 123 assert.Len(t, res.AndFilterCondition.FilterCriteria, 1) 124 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "message") 125 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, Or) 126 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("this"), []byte("is"), []byte("a"), []byte("test")}) 127 } 128 129 func Test_ParseRequest_match(t *testing.T) { 130 json_body := []byte(`{ 131 "query":{ 132 "bool": {"must" : 133 {"match": {"message": { 134 "query": "test", 135 "operator": "and" 136 }}} 137 }}}`) 138 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 139 assert.Nil(t, err) 140 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 141 assert.IsType(t, res, &ASTNode{}) 142 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "message") 143 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, And) 144 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("test")}) 145 } 146 147 func Test_ParseRequest_must_range_lte_Condition(t *testing.T) { 148 json_body := []byte(` 149 { 150 "query":{ 151 "bool": {"must" : 152 {"range" : { "age" : { 153 "lte": 10 154 }}}}}}`) 155 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 156 assert.Nil(t, err) 157 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 158 assert.IsType(t, res, &ASTNode{}) 159 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 160 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "10") 161 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, LessThanOrEqualTo) 162 163 } 164 165 func Test_ParseRequest_must_range_gte_Condition(t *testing.T) { 166 json_body := []byte(` 167 {"query":{ 168 "bool": {"must" : 169 {"range" : { "age" : { 170 "gte": 10 171 }}}}}}`) 172 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 173 assert.Nil(t, err) 174 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 175 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 176 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "10") 177 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, GreaterThanOrEqualTo) 178 179 } 180 181 func Test_ParseRequest_must_range_gt_lt_Condition(t *testing.T) { 182 json_body := []byte(` 183 {"query":{ 184 "bool": {"must" : 185 {"range" : { "age" : { 186 "gte": 10, 187 "lte": 20 188 }}}}}}`) 189 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 190 assert.Nil(t, err) 191 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 192 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 193 // assert.Equal(t, res.andFilterConditions[0].expressionFilter.rightInput.expression.leftInput.literal, "10") 194 // assert.Equal(t, res.andFilterConditions[0].expressionFilter.filterOperator, GreaterThanOrEqualTo) 195 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 196 // assert.Equal(t, res.andFilterConditions[1].expressionFilter.rightInput.expression.leftInput.literal, "20") 197 // assert.Equal(t, res.andFilterConditions[1].expressionFilter.filterOperator, LessThanOrEqualTo) 198 199 } 200 201 func Test_ParseRequest_must_range_timerange(t *testing.T) { 202 config.InitializeDefaultConfig() 203 json_body := []byte(` 204 {"query":{ 205 "bool": { 206 "must": [{ 207 "range": { 208 "timestamp": { 209 "gte": 1633000284000, 210 "lte": 1633000304000 211 } 212 } 213 }, 214 {"term": {"user.id" : "kimchy"}}] 215 } 216 }}`) 217 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 218 assert.Nil(t, err) 219 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 220 assert.IsType(t, res, &ASTNode{}) 221 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 222 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "kimchy") 223 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 224 225 assert.Equal(t, strconv.FormatUint(res.TimeRange.StartEpochMs, 10), "1633000284000") 226 assert.Equal(t, strconv.FormatUint(res.TimeRange.EndEpochMs, 10), "1633000304000") 227 228 } 229 230 func Test_ParseRequest_must_Terms(t *testing.T) { 231 json_body := []byte(`{"query":{ 232 "bool": {"must" : 233 {"terms" : { "user.id" : [ "kimchy", "elkbee" ] }} 234 }}}`) 235 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 236 assert.Nil(t, err) 237 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 238 assert.IsType(t, res, &ASTNode{}) 239 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "user.id") 240 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, Or) 241 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("kimchy"), []byte("elkbee")}) 242 } 243 244 func Test_ParseRequest_must_Terms_invalid_empty(t *testing.T) { 245 json_body := []byte(`{"query":{ 246 "bool": {"must" : 247 {"terms" : { "user.id" : [] }} 248 }}}`) 249 _, _, _, _, err := ParseRequest(json_body, 0, false) 250 assert.NotNil(t, err) 251 } 252 253 func Test_ParseRequest_must_Terms_invalid_nested(t *testing.T) { 254 json_body := []byte(`{"query":{ 255 "bool": {"must" : 256 {"terms" : {"message": { 257 "query": "test" 258 }}} 259 }}}`) 260 _, _, _, _, err := ParseRequest(json_body, 0, false) 261 assert.NotNil(t, err) 262 } 263 264 func Test_ParseRequest_must_Prefix(t *testing.T) { 265 json_body := []byte(`{"query":{ 266 "bool": {"must" : 267 {"prefix" : {"user.id": "ki"}} 268 }}}`) 269 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 270 assert.Nil(t, err) 271 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 272 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 273 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "ki*") 274 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 275 276 } 277 278 func Test_ParseRequest_must_Prefix_nested(t *testing.T) { 279 json_body := []byte(`{"query":{ 280 "bool": {"must" : 281 {"prefix" :{ "user.name": { 282 "value": "SK" 283 }}} 284 }}}`) 285 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 286 assert.Nil(t, err) 287 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 288 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.name") 289 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "SK*") 290 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 291 } 292 func Test_ParseRequest_must_Prefix_invalid(t *testing.T) { 293 json_body := []byte(`{"query":{ 294 "bool": {"must" : 295 {"prefix" :{ "user.name":{ 296 "value": ["SK"] 297 }}} 298 }}}`) 299 _, _, _, _, err := ParseRequest(json_body, 0, false) 300 assert.NotNil(t, err) 301 302 } 303 304 func Test_ParseRequest_must_Regexp(t *testing.T) { 305 json_body := []byte(`{"query":{ 306 "bool": {"must" : 307 {"regexp" :{"user.id": {"value": "k.*y"}} 308 } 309 }}}`) 310 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 311 assert.Nil(t, err) 312 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 313 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 314 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "k.*y") 315 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 316 317 } 318 319 func Test_ParseRequest_must_Wildcard(t *testing.T) { 320 json_body := []byte(`{"query":{ 321 "bool": {"must" : 322 {"wildcard" :{"user.id": {"value": "k.*y"}} 323 } 324 }}}`) 325 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 326 assert.Nil(t, err) 327 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 328 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 329 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "k.*y") 330 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 331 332 } 333 334 func Test_ParseRequest_query_string(t *testing.T) { 335 json_body := []byte(`{"query":{ 336 "bool": {"must" : 337 {"query_string": { 338 "query": "customer_full_name :\"Gwen Powell\"" 339 340 }} 341 }}}`) 342 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 343 assert.Nil(t, err) 344 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 345 assert.IsType(t, res, &ASTNode{}) 346 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "customer_full_name") 347 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 348 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "Gwen Powell") 349 } 350 351 func Test_ParseRequest_filter(t *testing.T) { 352 json_body := []byte(`{ 353 "query":{ 354 "bool": {"filter" : 355 {"term" : { "user.id" : "kimchy" }} 356 }}}`) 357 res, _, _, _, err := ParseRequest(json_body, 0, false) 358 assert.Nil(t, err) 359 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 360 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "kimchy") 361 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 362 } 363 364 func Test_ParseRequest_filter_term_array(t *testing.T) { 365 json_body := []byte(`{ 366 "query":{ 367 "bool": {"filter" : 368 [{"term" : { "user.id" : "kimchy" }}, 369 {"term" : { "id" : 123 }} 370 ] 371 }}}`) 372 res, _, _, _, err := ParseRequest(json_body, 0, false) 373 assert.Nil(t, err) 374 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 375 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "kimchy") 376 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 377 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "id") 378 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.UnsignedVal, uint64(123)) 379 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].ExpressionFilter.FilterOperator, Equals) 380 } 381 382 func Test_ParseRequest_filter_term_with_bool(t *testing.T) { 383 json_body := []byte(`{ 384 "query":{ 385 "bool": {"filter" : 386 [{"term" : { "user.id" : "kimchy" }}, 387 {"term" : { "device_is_mobile" : false }} 388 ] 389 }}}`) 390 res, _, _, _, err := ParseRequest(json_body, 0, false) 391 assert.Nil(t, err) 392 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 393 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "kimchy") 394 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 395 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "device_is_mobile") 396 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.BoolVal, uint8(0)) 397 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].ExpressionFilter.FilterOperator, Equals) 398 } 399 400 func Test_ParseRequest_filter_term_array_invalid(t *testing.T) { 401 json_body := []byte(`{ 402 "query":{ 403 "bool": {"filter" : 404 [{"term" : { "user.id" : "kimchy" }}, 405 "123" 406 ] 407 }}}`) 408 _, _, _, _, err := ParseRequest(json_body, 0, false) 409 assert.NotNil(t, err) 410 } 411 412 func Test_ParseRequest_filter_match_noQueryClause(t *testing.T) { 413 414 json_body := []byte(`{ 415 "query":{ 416 "bool": {"filter" : 417 {"match": {"message": "this is a test"}} 418 }}}`) 419 420 res, _, _, _, err := ParseRequest(json_body, 0, false) 421 assert.Nil(t, err) 422 assert.IsType(t, res, &ASTNode{}) 423 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "message") 424 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, Or) 425 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("this"), []byte("is"), []byte("a"), []byte("test")}) 426 } 427 428 func Test_ParseRequest_filter_match(t *testing.T) { 429 json_body := []byte(`{ 430 "query":{ 431 "bool": {"filter" : 432 {"match": {"message": { 433 "query": "test", 434 "operator": "and" 435 }}} 436 }}}`) 437 res, _, _, _, err := ParseRequest(json_body, 0, false) 438 assert.Nil(t, err) 439 assert.IsType(t, res, &ASTNode{}) 440 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "message") 441 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, And) 442 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("test")}) 443 444 } 445 446 func Test_ParseRequest_filter_range_lte_Condition(t *testing.T) { 447 json_body := []byte(` 448 { 449 "query":{ 450 "bool": {"filter" : 451 {"range" : { "age" : { 452 "lte": 10 453 }}}}}}`) 454 res, _, _, _, err := ParseRequest(json_body, 0, false) 455 assert.Nil(t, err) 456 assert.IsType(t, res, &ASTNode{}) 457 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 458 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "10") 459 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, LessThanOrEqualTo) 460 461 } 462 463 func Test_ParseRequest_filter_range_gte_Condition(t *testing.T) { 464 json_body := []byte(` 465 {"query":{ 466 "bool": {"filter" : 467 {"range" : { "age" : { 468 "gte": 10 469 }}}}}}`) 470 res, _, _, _, err := ParseRequest(json_body, 0, false) 471 assert.Nil(t, err) 472 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 473 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "10") 474 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, GreaterThanOrEqualTo) 475 476 } 477 478 func Test_ParseRequest_filter_range_gt_lt_Condition(t *testing.T) { 479 json_body := []byte(` 480 {"query":{ 481 "bool": {"filter" : 482 {"range" : { "age" : { 483 "gte": 10, 484 "lte": 20 485 }}}}}}`) 486 res, _, _, _, err := ParseRequest(json_body, 0, false) 487 assert.Nil(t, err) 488 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 489 // assert.Equal(t, res.andFilterConditions[0].expressionFilter.rightInput.expression.leftInput.literal, "10") 490 // assert.Equal(t, res.andFilterConditions[0].expressionFilter.filterOperator, GreaterThanOrEqualTo) 491 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 492 // assert.Equal(t, res.andFilterConditions[1].expressionFilter.rightInput.expression.leftInput.literal, "20") 493 // assert.Equal(t, res.andFilterConditions[1].expressionFilter.filterOperator, LessThanOrEqualTo) 494 495 } 496 497 func Test_ParseRequest_filter_range_timerange(t *testing.T) { 498 config.InitializeDefaultConfig() 499 json_body := []byte(` 500 {"query":{ 501 "bool": { 502 "filter": [{ 503 "range": { 504 "timestamp": { 505 "gte": 1633000284000, 506 "lte": 1633000304000, 507 "format": "epoch_millis" 508 } 509 } 510 }, 511 {"term": {"user.id" : "kimchy"}}] 512 } 513 }}`) 514 res, _, _, _, err := ParseRequest(json_body, 0, false) 515 assert.Nil(t, err) 516 assert.IsType(t, res, &ASTNode{}) 517 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 518 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "kimchy") 519 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 520 521 assert.Equal(t, strconv.FormatUint(res.TimeRange.StartEpochMs, 10), "1633000284000") 522 assert.Equal(t, strconv.FormatUint(res.TimeRange.EndEpochMs, 10), "1633000304000") 523 524 } 525 526 func Test_ParseRequest_filter_Terms(t *testing.T) { 527 json_body := []byte(`{"query":{ 528 "bool": {"filter" : 529 {"terms" : { "user.id" : [ "kimchy", "elkbee" ] }} 530 }}}`) 531 res, _, _, _, err := ParseRequest(json_body, 0, false) 532 assert.Nil(t, err) 533 assert.IsType(t, res, &ASTNode{}) 534 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "user.id") 535 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, Or) 536 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("kimchy"), []byte("elkbee")}) 537 } 538 539 func Test_ParseRequest_filter_Terms_invalid_empty(t *testing.T) { 540 json_body := []byte(`{"query":{ 541 "bool": {"filter" : 542 {"terms" : { "user.id" : [] }} 543 }}}`) 544 _, _, _, _, err := ParseRequest(json_body, 0, false) 545 assert.NotNil(t, err) 546 } 547 548 func Test_ParseRequest_filter_Terms_invalid_nested(t *testing.T) { 549 json_body := []byte(`{"query":{ 550 "bool": {"filter" : 551 {"terms" : {"message": { 552 "query": "test" 553 }}} 554 }}}`) 555 _, _, _, _, err := ParseRequest(json_body, 0, false) 556 assert.NotNil(t, err) 557 } 558 559 func Test_ParseRequest_filter_Prefix(t *testing.T) { 560 json_body := []byte(`{"query":{ 561 "bool": {"filter" : 562 {"prefix" : {"user.id": "ki"}} 563 }}}`) 564 res, _, _, _, err := ParseRequest(json_body, 0, false) 565 566 assert.Nil(t, err) 567 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 568 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "ki*") 569 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 570 571 } 572 573 func Test_ParseRequest_filter_Prefix_nested(t *testing.T) { 574 json_body := []byte(`{"query":{ 575 "bool": {"filter" : 576 {"prefix" :{ "user.name": { 577 "value": "SK" 578 }}} 579 }}}`) 580 res, _, _, _, err := ParseRequest(json_body, 0, false) 581 assert.Nil(t, err) 582 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.name") 583 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "SK*") 584 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 585 } 586 587 func Test_ParseRequest_filter_Prefix_invalid(t *testing.T) { 588 json_body := []byte(`{"query":{ 589 "bool": {"filter" : 590 {"prefix" :{ "user.name":{ 591 "value": ["SK"] 592 }}} 593 }}}`) 594 _, _, _, _, err := ParseRequest(json_body, 0, false) 595 assert.NotNil(t, err) 596 597 } 598 599 func Test_ParseRequest_filter_Regexp_multipleParams(t *testing.T) { 600 json_body := []byte(`{ 601 "query": { 602 "bool": { 603 "filter": [ 604 { 605 "regexp": { 606 "metric.raw": { 607 "value": "ConnectionPool-name1-.*\\.NumWaitingForConnections", 608 "flags_value": 255, 609 "max_determinized_states": 10000, 610 "boost": 1.0 611 } 612 } 613 }, 614 { 615 "regexp": { 616 "scope.raw": { 617 "value": "core\\.PH2\\..*\\.(na|eu|um|ap|cs|gs).*", 618 "flags_value": 255, 619 "max_determinized_states": 10000, 620 "boost": 1.0 621 } 622 } 623 }, 624 { 625 "regexp": { 626 "tagk.raw": { 627 "value": "device", 628 "flags_value": 255, 629 "max_determinized_states": 10000, 630 "boost": 1.0 631 } 632 } 633 }, 634 { 635 "regexp": { 636 "tagv.raw": { 637 "value": ".*-app.*-.*", 638 "flags_value": 255, 639 "max_determinized_states": 10000, 640 "boost": 1.0 641 } 642 } 643 }, 644 { 645 "range": { 646 "mts": { 647 "from": 1638627863984, 648 "to": 1639491866710, 649 "include_lower": true, 650 "include_upper": true, 651 "boost": 1.0 652 } 653 } 654 } 655 ], 656 "adjust_pure_negative": true, 657 "boost": 1.0 658 } 659 } 660 }`) 661 res, _, _, _, err := ParseRequest(json_body, 0, false) 662 663 assert.Nil(t, err) 664 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "metric") 665 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "ConnectionPool-name1-.*\\.NumWaitingForConnections") 666 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 667 } 668 669 func Test_ParseRequest_filter_Regexp(t *testing.T) { 670 json_body := []byte(`{"query":{ 671 "bool": {"filter" : 672 {"regexp" :{"user.id": {"value": "k.*y"}} 673 } 674 }}}`) 675 res, _, _, _, err := ParseRequest(json_body, 0, false) 676 677 assert.Nil(t, err) 678 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 679 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "k.*y") 680 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 681 682 } 683 684 func Test_ParseRequest_filter_Wildcard(t *testing.T) { 685 json_body := []byte(`{"query":{ 686 "bool": {"filter" : 687 {"wildcard" :{"user.id": {"value": "k.*y"}} 688 } 689 }}}`) 690 res, _, _, _, err := ParseRequest(json_body, 0, false) 691 assert.Nil(t, err) 692 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 693 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "k.*y") 694 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 695 696 } 697 698 func Test_ParseRequest_filter_query_string(t *testing.T) { 699 json_body := []byte(`{"query":{ 700 "bool": {"filter" : 701 {"query_string": { 702 "analyze_wildcard": true, 703 "query": "col1:abc" 704 }} 705 }}}`) 706 res, _, _, _, err := ParseRequest(json_body, 0, false) 707 assert.Nil(t, err) 708 assert.IsType(t, res, &ASTNode{}) 709 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col1") 710 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 711 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "abc") 712 } 713 714 func Test_ParseRequest_should(t *testing.T) { 715 json_body := []byte(`{ 716 "query":{ 717 "bool": {"should" : 718 {"term" : { "user.id" : "kimchy" }} 719 }}}`) 720 res, _, _, _, err := ParseRequest(json_body, 0, false) 721 assert.Nil(t, err) 722 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 723 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "kimchy") 724 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 725 } 726 727 func Test_ParseRequest_should_term_array(t *testing.T) { 728 json_body := []byte(`{ 729 "query":{ 730 "bool": {"should" : 731 [{"term" : { "user.id" : "kimchy" }}, 732 {"term" : { "id" : 123 }} 733 ] 734 }}}`) 735 res, _, _, _, err := ParseRequest(json_body, 0, false) 736 assert.Nil(t, err) 737 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 738 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "kimchy") 739 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 740 assert.Equal(t, res.OrFilterCondition.FilterCriteria[1].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "id") 741 assert.Equal(t, res.OrFilterCondition.FilterCriteria[1].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.UnsignedVal, uint64(123)) 742 assert.Equal(t, res.OrFilterCondition.FilterCriteria[1].ExpressionFilter.FilterOperator, Equals) 743 744 } 745 746 func Test_ParseRequest_should_term_array_invalid(t *testing.T) { 747 json_body := []byte(`{ 748 "query":{ 749 "bool": {"should" : 750 [{"term" : { "user.id" : "kimchy" }}, 751 "123" 752 ] 753 }}}`) 754 _, _, _, _, err := ParseRequest(json_body, 0, false) 755 assert.NotNil(t, err) 756 } 757 758 func Test_ParseRequest_should_match_noQueryClause(t *testing.T) { 759 760 json_body := []byte(`{ 761 "query":{ 762 "bool": {"should" : 763 {"match": {"message": "this is a test"}} 764 }}}`) 765 766 res, _, _, _, err := ParseRequest(json_body, 0, false) 767 assert.Nil(t, err) 768 assert.IsType(t, res, &ASTNode{}) 769 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "message") 770 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, Or) 771 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("this"), []byte("is"), []byte("a"), []byte("test")}) 772 } 773 774 func Test_ParseRequest_should_match(t *testing.T) { 775 json_body := []byte(`{ 776 "query":{ 777 "bool": {"should" : 778 {"match": {"message": { 779 "query": "test", 780 "operator": "and" 781 }}} 782 }}}`) 783 res, _, _, _, err := ParseRequest(json_body, 0, false) 784 assert.Nil(t, err) 785 assert.IsType(t, res, &ASTNode{}) 786 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "message") 787 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, And) 788 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("test")}) 789 } 790 791 func Test_ParseRequest_should_range_lte_Condition(t *testing.T) { 792 json_body := []byte(` 793 { 794 "query":{ 795 "bool": {"should" : 796 {"range" : { "age" : { 797 "lte": 10 798 }}}}}}`) 799 res, _, _, _, err := ParseRequest(json_body, 0, false) 800 assert.Nil(t, err) 801 assert.IsType(t, res, &ASTNode{}) 802 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 803 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "10") 804 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, LessThanOrEqualTo) 805 806 } 807 808 func Test_ParseRequest_should_range_gte_Condition(t *testing.T) { 809 json_body := []byte(` 810 {"query":{ 811 "bool": {"should" : 812 {"range" : { "age" : { 813 "gte": 10 814 }}}}}}`) 815 res, _, _, _, err := ParseRequest(json_body, 0, false) 816 assert.Nil(t, err) 817 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 818 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "10") 819 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, GreaterThanOrEqualTo) 820 821 } 822 823 func Test_ParseRequest_should_range_gt_lt_Condition(t *testing.T) { 824 json_body := []byte(` 825 {"query":{ 826 "bool": {"should" : 827 {"range" : { "age" : { 828 "gte": 10, 829 "lte": 20 830 }}}}}}`) 831 res, _, _, _, err := ParseRequest(json_body, 0, false) 832 assert.Nil(t, err) 833 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 834 // assert.Equal(t, res.andFilterConditions[0].expressionFilter.rightInput.expression.leftInput.literal, "10") 835 // assert.Equal(t, res.andFilterConditions[0].expressionFilter.filterOperator, GreaterThanOrEqualTo) 836 assert.Equal(t, res.OrFilterCondition.FilterCriteria[1].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 837 // assert.Equal(t, res.andFilterConditions[1].expressionFilter.rightInput.expression.leftInput.literal, "20") 838 // assert.Equal(t, res.andFilterConditions[1].expressionFilter.filterOperator, LessThanOrEqualTo) 839 840 } 841 842 func Test_ParseRequest_should_range_timerange(t *testing.T) { 843 config.InitializeDefaultConfig() 844 json_body := []byte(` 845 {"query":{ 846 "bool": { 847 "should": [{ 848 "range": { 849 "timestamp": { 850 "gte": 1633000284000, 851 "lte": 1633000304000, 852 "format": "epoch_millis" 853 } 854 } 855 }, 856 {"term": {"user.id" : "kimchy"}}] 857 } 858 }}`) 859 res, _, _, _, err := ParseRequest(json_body, 0, false) 860 assert.Nil(t, err) 861 assert.IsType(t, res, &ASTNode{}) 862 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 863 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "kimchy") 864 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 865 866 assert.Equal(t, strconv.FormatUint(res.TimeRange.StartEpochMs, 10), "1633000284000") 867 assert.Equal(t, strconv.FormatUint(res.TimeRange.EndEpochMs, 10), "1633000304000") 868 869 } 870 871 func Test_ParseRequest_should_Terms(t *testing.T) { 872 json_body := []byte(`{"query":{ 873 "bool": {"should" : 874 {"terms" : { "user.id" : [ "kimchy", "elkbee" ] }} 875 }}}`) 876 res, _, _, _, err := ParseRequest(json_body, 0, false) 877 assert.Nil(t, err) 878 assert.IsType(t, res, &ASTNode{}) 879 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "user.id") 880 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, Or) 881 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("kimchy"), []byte("elkbee")}) 882 883 } 884 885 func Test_ParseRequest_should_Terms_invalid_empty(t *testing.T) { 886 json_body := []byte(`{"query":{ 887 "bool": {"should" : 888 {"terms" : { "user.id" : [] }} 889 }}}`) 890 _, _, _, _, err := ParseRequest(json_body, 0, false) 891 assert.NotNil(t, err) 892 } 893 894 func Test_ParseRequest_should_Terms_invalid_nested(t *testing.T) { 895 json_body := []byte(`{"query":{ 896 "bool": {"should" : 897 {"terms" : {"message": { 898 "query": "test" 899 }}} 900 }}}`) 901 _, _, _, _, err := ParseRequest(json_body, 0, false) 902 assert.NotNil(t, err) 903 } 904 905 func Test_ParseRequest_should_Prefix(t *testing.T) { 906 json_body := []byte(`{"query":{ 907 "bool": {"should" : 908 {"prefix" : {"user.id": "ki"}} 909 }}}`) 910 res, _, _, _, err := ParseRequest(json_body, 0, false) 911 912 assert.Nil(t, err) 913 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 914 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "ki*") 915 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 916 917 } 918 919 func Test_ParseRequest_should_Prefix_nested(t *testing.T) { 920 json_body := []byte(`{"query":{ 921 "bool": {"should" : 922 {"prefix" :{ "user.name": { 923 "value": "SK" 924 }}} 925 }}}`) 926 res, _, _, _, err := ParseRequest(json_body, 0, false) 927 assert.Nil(t, err) 928 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.name") 929 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "SK*") 930 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 931 } 932 933 func Test_ParseRequest_should_Prefix_invalid(t *testing.T) { 934 json_body := []byte(`{"query":{ 935 "bool": {"should" : 936 {"prefix" :{ "user.name":{ 937 "value": ["SK"] 938 }}} 939 }}}`) 940 _, _, _, _, err := ParseRequest(json_body, 0, false) 941 assert.NotNil(t, err) 942 943 } 944 945 func Test_ParseRequest_should_Regexp(t *testing.T) { 946 json_body := []byte(`{"query":{ 947 "bool": {"should" : 948 {"regexp" :{"user.id": {"value": "k.*y"}} 949 } 950 }}}`) 951 res, _, _, _, err := ParseRequest(json_body, 0, false) 952 953 assert.Nil(t, err) 954 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 955 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "k.*y") 956 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 957 958 } 959 960 func Test_ParseRequest_should_Wildcard(t *testing.T) { 961 json_body := []byte(`{"query":{ 962 "bool": {"should" : 963 {"wildcard" :{"user.id": {"value": "k.*y"}} 964 } 965 }}}`) 966 res, _, _, _, err := ParseRequest(json_body, 0, false) 967 assert.Nil(t, err) 968 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 969 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "k.*y") 970 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 971 972 } 973 974 func Test_ParseRequest_should_query_string(t *testing.T) { 975 json_body := []byte(`{"query":{ 976 "bool": {"should" : 977 {"query_string": { 978 "analyze_wildcard": true, 979 "query": "col1:abc" 980 }} 981 }}}`) 982 res, _, _, _, err := ParseRequest(json_body, 0, false) 983 assert.Nil(t, err) 984 assert.IsType(t, res, &ASTNode{}) 985 assert.Len(t, res.OrFilterCondition.FilterCriteria, 1) 986 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col1") 987 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 988 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "abc") 989 } 990 991 func Test_parseQuery_multiple(t *testing.T) { 992 json_body := []byte(`{"query":{ 993 "bool":{ 994 "must": 995 { "term": { "title": "Search" }}, 996 "should": 997 { "term": { "status": "published" }} 998 999 }}}`) 1000 res, _, _, _, err := ParseRequest(json_body, 0, false) 1001 assert.Nil(t, err) 1002 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "title") 1003 assert.Equal(t, res.OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "status") 1004 } 1005 1006 func Test_aggregationParsing(t *testing.T) { 1007 json_body := []byte(`{"aggs": { 1008 "2": { 1009 "date_histogram": { 1010 "interval": "2h", 1011 "field": "timestamp", 1012 "min_doc_count": 0, 1013 "extended_bounds": { 1014 "min": 0, 1015 "max": 10 1016 }, 1017 "format": "epoch_millis" 1018 }, 1019 "aggs": {} 1020 } 1021 }}`) 1022 _, agg, _, _, err := ParseRequest(json_body, 0, false) 1023 assert.Nil(t, err) 1024 assert.Equal(t, uint64(7_200_000), agg.TimeHistogram.IntervalMillis) 1025 assert.Equal(t, "2", agg.TimeHistogram.AggName) 1026 assert.Equal(t, uint64(0), agg.TimeHistogram.StartTime) 1027 assert.Equal(t, uint64(10_000), agg.TimeHistogram.EndTime, "test conversion to millis") 1028 } 1029 1030 func Test_ParseRequest_query_aggs(t *testing.T) { 1031 json_body := []byte(`{"query":{ 1032 "bool": {"filter" : 1033 {"wildcard" :{"user.id": {"value": "k.*y"}} 1034 } 1035 }},"aggs": { 1036 "2": { 1037 "date_histogram": { 1038 "interval": "2h", 1039 "field": "timestamp", 1040 "min_doc_count": 0, 1041 "extended_bounds": { 1042 "min": 0, 1043 "max": 10 1044 }, 1045 "format": "epoch_millis" 1046 }, 1047 "aggs": {} 1048 } 1049 }}`) 1050 res, agg, _, _, err := ParseRequest(json_body, 0, false) 1051 assert.Nil(t, err) 1052 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 1053 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "k.*y") 1054 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1055 1056 assert.NotNil(t, agg.TimeHistogram) 1057 assert.Equal(t, uint64(7_200_000), agg.TimeHistogram.IntervalMillis) 1058 assert.Equal(t, "2", agg.TimeHistogram.AggName) 1059 assert.Equal(t, uint64(0), agg.TimeHistogram.StartTime) 1060 assert.Equal(t, uint64(10_000), agg.TimeHistogram.EndTime) 1061 1062 } 1063 1064 func Test_ParseRequest_GroupByTerms(t *testing.T) { 1065 json_body := []byte(`{"aggs":{"2":{"terms":{"field":"a","size":10,"order":{"_term":"desc"},"min_doc_count":1},"aggs":{}}}}`) 1066 _, agg, _, _, err := ParseRequest(json_body, 0, false) 1067 assert.Nil(t, err) 1068 assert.NotNil(t, agg.GroupByRequest) 1069 assert.Equal(t, "a", agg.GroupByRequest.GroupByColumns[0]) 1070 assert.Equal(t, Count, agg.GroupByRequest.MeasureOperations[0].MeasureFunc) 1071 assert.Equal(t, "a", agg.GroupByRequest.MeasureOperations[0].MeasureCol) 1072 assert.Equal(t, "2", agg.GroupByRequest.AggName) 1073 1074 } 1075 1076 func Test_ParseRequest_SimpleNestedAgg(t *testing.T) { 1077 json_body := []byte(`{"aggs":{"2":{"aggs":{"agg1":{"terms":{"field": "vpcName"}},"3":{"avg":{"field":"a"}}}}}}`) 1078 _, agg, _, _, err := ParseRequest(json_body, 0, false) 1079 assert.Nil(t, err) 1080 assert.NotNil(t, agg.GroupByRequest) 1081 assert.Equal(t, "vpcName", agg.GroupByRequest.GroupByColumns[0]) 1082 assert.Equal(t, Avg, agg.GroupByRequest.MeasureOperations[0].MeasureFunc) 1083 assert.Equal(t, "a", agg.GroupByRequest.MeasureOperations[0].MeasureCol) 1084 assert.Equal(t, "2", agg.GroupByRequest.AggName) 1085 } 1086 1087 func Test_ParseRequest_MultipleGroupByTerms(t *testing.T) { 1088 json_body := []byte(`{"aggs":{"2":{"aggs":{"agg1":{"terms":{"field": "vpcName"}},"3":{"avg":{"field":"a"}}},"terms":{"field": "vpcID"}}}}`) 1089 _, agg, _, _, err := ParseRequest(json_body, 0, false) 1090 assert.Nil(t, err) 1091 assert.NotNil(t, agg.GroupByRequest) 1092 assert.Contains(t, agg.GroupByRequest.GroupByColumns, "vpcName") 1093 assert.Contains(t, agg.GroupByRequest.GroupByColumns, "vpcID") 1094 assert.Len(t, agg.GroupByRequest.GroupByColumns, 2) 1095 assert.Equal(t, Avg, agg.GroupByRequest.MeasureOperations[0].MeasureFunc) 1096 assert.Equal(t, "a", agg.GroupByRequest.MeasureOperations[0].MeasureCol) 1097 assert.Equal(t, "2", agg.GroupByRequest.AggName) 1098 1099 } 1100 1101 func Test_ParseRequest_MultipleGroupByTerms_NoMeasureAgg(t *testing.T) { 1102 json_body := []byte(`{"aggs":{"2":{"aggs":{"agg1":{"terms":{"field": "vpcName"}}},"terms":{"field": "vpcID"}}}}`) 1103 _, agg, _, _, err := ParseRequest(json_body, 0, false) 1104 assert.Nil(t, err) 1105 assert.NotNil(t, agg.GroupByRequest) 1106 assert.Contains(t, agg.GroupByRequest.GroupByColumns, "vpcName") 1107 assert.Contains(t, agg.GroupByRequest.GroupByColumns, "vpcID") 1108 assert.Len(t, agg.GroupByRequest.GroupByColumns, 2) 1109 assert.Len(t, agg.GroupByRequest.MeasureOperations, 2) 1110 if agg.GroupByRequest.MeasureOperations[0].MeasureCol == "vpcName" && agg.GroupByRequest.MeasureOperations[0].MeasureFunc == Count { 1111 if agg.GroupByRequest.MeasureOperations[1].MeasureCol == "vpcID" && agg.GroupByRequest.MeasureOperations[1].MeasureFunc == Count { 1112 } else { 1113 assert.Fail(t, "wrong measure ops %+v", agg.GroupByRequest.MeasureOperations) 1114 } 1115 } else if agg.GroupByRequest.MeasureOperations[0].MeasureCol == "vpcID" && agg.GroupByRequest.MeasureOperations[0].MeasureFunc == Count { 1116 if agg.GroupByRequest.MeasureOperations[1].MeasureCol == "vpcName" && agg.GroupByRequest.MeasureOperations[1].MeasureFunc == Count { 1117 1118 } else { 1119 assert.Fail(t, "wrong measure ops %+v", agg.GroupByRequest.MeasureOperations) 1120 } 1121 } else { 1122 assert.Fail(t, "wrong measure ops %+v", agg.GroupByRequest.MeasureOperations) 1123 } 1124 assert.Equal(t, "2", agg.GroupByRequest.AggName) 1125 } 1126 1127 func Test_ParseRequest_SimpleAgg(t *testing.T) { 1128 json_body := []byte(`{"aggs":{"2":{"terms":{"field": "vpcName"}}}}`) 1129 _, agg, _, _, err := ParseRequest(json_body, 0, false) 1130 assert.Nil(t, err) 1131 assert.NotNil(t, agg.GroupByRequest) 1132 assert.Equal(t, "vpcName", agg.GroupByRequest.GroupByColumns[0]) 1133 assert.Equal(t, Count, agg.GroupByRequest.MeasureOperations[0].MeasureFunc) 1134 assert.Equal(t, "vpcName", agg.GroupByRequest.MeasureOperations[0].MeasureCol) 1135 assert.Equal(t, "2", agg.GroupByRequest.AggName) 1136 } 1137 1138 func Test_ParseRequest_SimpleDateHistogram(t *testing.T) { 1139 json_body := []byte(`{ 1140 "aggs": { 1141 "2": { 1142 "date_histogram": { 1143 "interval": "2h", 1144 "field": "timestamp", 1145 "min_doc_count": 0, 1146 "extended_bounds": { 1147 "min": 0, 1148 "max": 10 1149 }, 1150 "format": "epoch_millis" 1151 } 1152 } 1153 } 1154 }`) 1155 _, agg, _, _, err := ParseRequest(json_body, 0, false) 1156 assert.Nil(t, err) 1157 assert.NotNil(t, agg.TimeHistogram) 1158 assert.Equal(t, uint64(7_200_000), agg.TimeHistogram.IntervalMillis) 1159 assert.Equal(t, "2", agg.TimeHistogram.AggName) 1160 assert.Equal(t, uint64(0), agg.TimeHistogram.StartTime) 1161 assert.Equal(t, uint64(10_000), agg.TimeHistogram.EndTime) 1162 } 1163 func Test_ParseRequest_FilterHistogram(t *testing.T) { 1164 json_body := []byte(`{"aggs":{"2":{"filters":{"filters":{"internet":{"query_string":{"query":"col1: abc","analyze_wildcard":true}}}},"aggs":{}}}}`) 1165 _, _, _, _, err := ParseRequest(json_body, 0, false) 1166 assert.NotNil(t, err) 1167 1168 } 1169 1170 func Test_ParseRequest_FilterAgg(t *testing.T) { 1171 json_body := []byte(`{"aggs":{"2":{"filters":{"filters":{"internet":{"query_string":{"query":"col1: abc","analyze_wildcard":true}}}},"aggs":{"3":{"avg":{"field":"a"}}}}}}`) 1172 _, _, _, _, err := ParseRequest(json_body, 0, false) 1173 assert.NotNil(t, err) 1174 } 1175 1176 func Test_ParseSize(t *testing.T) { 1177 json_body := []byte(`{"size":20,"query":{"bool": {"should" :{"terms" : { "user.id" : [ "kimchy", "elkbee" ] }}}}}`) 1178 _, _, size, _, err := ParseRequest(json_body, 0, false) 1179 assert.Nil(t, err) 1180 assert.Equal(t, uint64(20), size) 1181 } 1182 1183 func Test_ParseRequest_must_not(t *testing.T) { 1184 json_body := []byte(`{ 1185 "query":{ 1186 "bool": {"must_not" : 1187 {"term" : { "user.id" : "kimchy" }} 1188 }}}`) 1189 res, _, _, _, err := ParseRequest(json_body, 0, false) 1190 assert.Nil(t, err) 1191 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 1192 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "kimchy") 1193 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1194 } 1195 1196 func Test_ParseRequest_must_not_term_array(t *testing.T) { 1197 json_body := []byte(`{ 1198 "query":{ 1199 "bool": {"must_not" : 1200 [{"term" : { "user.id" : "kimchy" }}, 1201 {"term" : { "id" : 123 }} 1202 ] 1203 }}}`) 1204 res, _, _, _, err := ParseRequest(json_body, 0, false) 1205 assert.Nil(t, err) 1206 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 1207 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "kimchy") 1208 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1209 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[1].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "id") 1210 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[1].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.UnsignedVal, uint64(123)) 1211 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[1].ExpressionFilter.FilterOperator, Equals) 1212 1213 } 1214 1215 func Test_ParseRequest_must_not_term_array_invalid(t *testing.T) { 1216 json_body := []byte(`{ 1217 "query":{ 1218 "bool": {"must_not" : 1219 [{"term" : { "user.id" : "kimchy" }}, 1220 "123" 1221 ] 1222 }}}`) 1223 _, _, _, _, err := ParseRequest(json_body, 0, false) 1224 assert.NotNil(t, err) 1225 } 1226 1227 func Test_ParseRequest_must_not_match_noQueryClause(t *testing.T) { 1228 1229 json_body := []byte(`{ 1230 "query":{ 1231 "bool": {"must_not" : 1232 {"match": {"message": "this is a test"}} 1233 }}}`) 1234 1235 res, _, _, _, err := ParseRequest(json_body, 0, false) 1236 assert.Nil(t, err) 1237 assert.IsType(t, res, &ASTNode{}) 1238 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "message") 1239 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, Or) 1240 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("this"), []byte("is"), []byte("a"), []byte("test")}) 1241 } 1242 1243 func Test_ParseRequest_must_not_match(t *testing.T) { 1244 json_body := []byte(`{ 1245 "query":{ 1246 "bool": {"must_not" : 1247 {"match": {"message": { 1248 "query": "test", 1249 "operator": "and" 1250 }}} 1251 }}}`) 1252 res, _, _, _, err := ParseRequest(json_body, 0, false) 1253 assert.Nil(t, err) 1254 assert.IsType(t, res, &ASTNode{}) 1255 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "message") 1256 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, And) 1257 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("test")}) 1258 } 1259 1260 func Test_ParseRequest_must_not_range_lte_Condition(t *testing.T) { 1261 json_body := []byte(` 1262 { 1263 "query":{ 1264 "bool": {"must_not" : 1265 {"range" : { "age" : { 1266 "lte": 10 1267 }}}}}}`) 1268 res, _, _, _, err := ParseRequest(json_body, 0, false) 1269 assert.Nil(t, err) 1270 assert.IsType(t, res, &ASTNode{}) 1271 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 1272 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "10") 1273 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, LessThanOrEqualTo) 1274 1275 } 1276 1277 func Test_ParseRequest_must_not_range_gte_Condition(t *testing.T) { 1278 json_body := []byte(` 1279 {"query":{ 1280 "bool": {"must_not" : 1281 {"range" : { "age" : { 1282 "gte": 10 1283 }}}}}}`) 1284 res, _, _, _, err := ParseRequest(json_body, 0, false) 1285 assert.Nil(t, err) 1286 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 1287 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "10") 1288 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, GreaterThanOrEqualTo) 1289 } 1290 1291 func Test_ParseRequest_must_not_range_gt_lt_Condition(t *testing.T) { 1292 json_body := []byte(` 1293 {"query":{ 1294 "bool": {"must_not" : 1295 {"range" : { "age" : { 1296 "gte": 10, 1297 "lte": 20 1298 }}}}}}`) 1299 res, _, _, _, err := ParseRequest(json_body, 0, false) 1300 assert.Nil(t, err) 1301 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 1302 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[1].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "age") 1303 } 1304 1305 func Test_ParseRequest_must_not_range_timerange(t *testing.T) { 1306 config.InitializeDefaultConfig() 1307 json_body := []byte(` 1308 {"query":{ 1309 "bool": { 1310 "must_not": [{ 1311 "range": { 1312 "timestamp": { 1313 "gte": 1633000284000, 1314 "lte": 1633000304000, 1315 "format": "epoch_millis" 1316 } 1317 } 1318 }, 1319 {"term": {"user.id" : "kimchy"}}] 1320 } 1321 }}`) 1322 res, _, _, _, err := ParseRequest(json_body, 0, false) 1323 assert.Nil(t, err) 1324 assert.IsType(t, res, &ASTNode{}) 1325 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 1326 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "kimchy") 1327 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1328 1329 assert.Equal(t, strconv.FormatUint(res.TimeRange.StartEpochMs, 10), "1633000284000") 1330 assert.Equal(t, strconv.FormatUint(res.TimeRange.EndEpochMs, 10), "1633000304000") 1331 1332 } 1333 1334 func Test_ParseRequest_must_not_Terms(t *testing.T) { 1335 json_body := []byte(`{"query":{ 1336 "bool": {"must_not" : 1337 {"terms" : { "user.id" : [ "kimchy", "elkbee" ] }} 1338 }}}`) 1339 res, _, _, _, err := ParseRequest(json_body, 0, false) 1340 assert.Nil(t, err) 1341 assert.IsType(t, res, &ASTNode{}) 1342 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "user.id") 1343 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, Or) 1344 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("kimchy"), []byte("elkbee")}) 1345 } 1346 1347 func Test_ParseRequest_must_not_Terms_invalid_empty(t *testing.T) { 1348 json_body := []byte(`{"query":{ 1349 "bool": {"must_not" : 1350 {"terms" : { "user.id" : [] }} 1351 }}}`) 1352 _, _, _, _, err := ParseRequest(json_body, 0, false) 1353 assert.NotNil(t, err) 1354 } 1355 1356 func Test_ParseRequest_must_not_Terms_invalid_nested(t *testing.T) { 1357 json_body := []byte(`{"query":{ 1358 "bool": {"must_not" : 1359 {"terms" : {"message": { 1360 "query": "test" 1361 }}} 1362 }}}`) 1363 _, _, _, _, err := ParseRequest(json_body, 0, false) 1364 assert.NotNil(t, err) 1365 } 1366 1367 func Test_ParseRequest_must_not_Prefix(t *testing.T) { 1368 json_body := []byte(`{"query":{ 1369 "bool": {"must_not" : 1370 {"prefix" : {"user.id": "ki"}} 1371 }}}`) 1372 res, _, _, _, err := ParseRequest(json_body, 0, false) 1373 1374 assert.Nil(t, err) 1375 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 1376 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "ki*") 1377 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1378 } 1379 1380 func Test_ParseRequest_must_not_Prefix_nested(t *testing.T) { 1381 json_body := []byte(`{"query":{ 1382 "bool": {"must_not" : 1383 {"prefix" :{ "user.name": { 1384 "value": "SK" 1385 }}} 1386 }}}`) 1387 res, _, _, _, err := ParseRequest(json_body, 0, false) 1388 assert.Nil(t, err) 1389 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.name") 1390 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "SK*") 1391 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1392 } 1393 1394 func Test_ParseRequest_must_not_Prefix_invalid(t *testing.T) { 1395 json_body := []byte(`{"query":{ 1396 "bool": {"must_not" : 1397 {"prefix" :{ "user.name":{ 1398 "value": ["SK"] 1399 }}} 1400 }}}`) 1401 _, _, _, _, err := ParseRequest(json_body, 0, false) 1402 assert.NotNil(t, err) 1403 1404 } 1405 1406 func Test_ParseRequest_must_not_Regexp(t *testing.T) { 1407 json_body := []byte(`{"query":{ 1408 "bool": {"must_not" : 1409 {"regexp" :{"user.id": {"value": "k.*y"}} 1410 } 1411 }}}`) 1412 res, _, _, _, err := ParseRequest(json_body, 0, false) 1413 1414 assert.Nil(t, err) 1415 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 1416 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "k.*y") 1417 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1418 } 1419 1420 func Test_ParseRequest_must_not_Wildcard(t *testing.T) { 1421 json_body := []byte(`{"query":{ 1422 "bool": {"must_not" : 1423 {"wildcard" :{"user.id": {"value": "k.*y"}} 1424 } 1425 }}}`) 1426 res, _, _, _, err := ParseRequest(json_body, 0, false) 1427 assert.Nil(t, err) 1428 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user.id") 1429 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "k.*y") 1430 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1431 1432 } 1433 1434 func Test_ParseRequest_must_not_query_string(t *testing.T) { 1435 json_body := []byte(`{"query":{ 1436 "bool": {"must_not" : 1437 {"query_string": { 1438 "analyze_wildcard": true, 1439 "query": "col1:abc" 1440 }} 1441 }}}`) 1442 res, _, _, _, err := ParseRequest(json_body, 0, false) 1443 assert.Nil(t, err) 1444 assert.IsType(t, res, &ASTNode{}) 1445 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col1") 1446 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1447 assert.Equal(t, res.ExclusionFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "abc") 1448 } 1449 1450 func Test_ParseRequest_must_query_string_AND(t *testing.T) { 1451 json_body := []byte(`{"query":{ 1452 "bool": {"must" : 1453 {"query_string": { 1454 "analyze_wildcard": true, 1455 "default_field": "*", 1456 "query": "col1:abc AND col2:abcd" 1457 }} 1458 }}}`) 1459 res, _, _, _, err := ParseRequest(json_body, 0, false) 1460 assert.Nil(t, err) 1461 assert.IsType(t, res, &ASTNode{}) 1462 assert.Len(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria, 2) 1463 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col1") 1464 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "abc") 1465 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1466 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col2") 1467 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "abcd") 1468 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].ExpressionFilter.FilterOperator, Equals) 1469 1470 } 1471 1472 func Test_ParseRequest_must_query_string_OR(t *testing.T) { 1473 json_body := []byte(`{"query":{ 1474 "bool": {"must" : 1475 {"query_string": { 1476 "analyze_wildcard": true, 1477 "default_field": "*", 1478 "query": "col1:abc OR col2:abcd" 1479 }} 1480 }}}`) 1481 res, _, _, _, err := ParseRequest(json_body, 0, false) 1482 assert.Nil(t, err) 1483 assert.IsType(t, res, &ASTNode{}) 1484 assert.Len(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria, 2) 1485 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col1") 1486 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "abc") 1487 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1488 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col2") 1489 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "abcd") 1490 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].ExpressionFilter.FilterOperator, Equals) 1491 1492 } 1493 1494 func Test_ParseRequest_must_query_string_Key_value_OR(t *testing.T) { 1495 json_body := []byte(`{"query":{ 1496 "bool": {"must" : 1497 {"query_string": { 1498 "analyze_wildcard": true, 1499 "default_field": "*", 1500 "query": "col1:(abc OR abcd)" 1501 }} 1502 }}}`) 1503 res, _, _, _, err := ParseRequest(json_body, 0, false) 1504 assert.Nil(t, err) 1505 assert.IsType(t, res, &ASTNode{}) 1506 assert.Len(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria, 2) 1507 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col1") 1508 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "abc") 1509 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1510 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col1") 1511 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "abcd") 1512 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].ExpressionFilter.FilterOperator, Equals) 1513 1514 } 1515 1516 func Test_ParseRequest_must_query_string_AND_OR(t *testing.T) { 1517 json_body := []byte(`{"query":{ 1518 "bool": {"must" : 1519 {"query_string": { 1520 "analyze_wildcard": true, 1521 "default_field": "*", 1522 "query": "(col1:abc AND col2:abcd) OR col3 : eee" 1523 }} 1524 }}}`) 1525 res, _, _, _, err := ParseRequest(json_body, 0, false) 1526 assert.Nil(t, err) 1527 assert.IsType(t, res, &ASTNode{}) 1528 assert.Len(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria, 1) 1529 assert.Len(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria, 2) 1530 1531 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col1") 1532 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "abc") 1533 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1534 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col2") 1535 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "abcd") 1536 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].ExpressionFilter.FilterOperator, Equals) 1537 1538 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col3") 1539 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "eee") 1540 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1541 1542 } 1543 1544 func Test_ParseRequest_must_query_string_AND_values(t *testing.T) { 1545 json_body := []byte(`{"query":{ 1546 "bool": {"must" : 1547 {"query_string": { 1548 "analyze_wildcard": true, 1549 "default_field": "*", 1550 "query": "val1 AND val2" 1551 }} 1552 }}}`) 1553 res, _, _, _, err := ParseRequest(json_body, 0, false) 1554 assert.Nil(t, err) 1555 assert.IsType(t, res, &ASTNode{}) 1556 assert.Len(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria, 2) 1557 1558 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "*") 1559 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("val1")}) 1560 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, Or) 1561 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].MatchFilter.MatchColumn, "*") 1562 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].MatchFilter.MatchWords, [][]byte{[]byte("val2")}) 1563 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].MatchFilter.MatchOperator, Or) 1564 1565 } 1566 1567 func Test_ParseRequest_must_query_string_OR_values(t *testing.T) { 1568 json_body := []byte(`{"query":{ 1569 "bool": {"must" : 1570 {"query_string": { 1571 "analyze_wildcard": true, 1572 "default_field": "*", 1573 "query": "val1 OR val2" 1574 }} 1575 }}}`) 1576 res, _, _, _, err := ParseRequest(json_body, 0, false) 1577 assert.Nil(t, err) 1578 assert.IsType(t, res, &ASTNode{}) 1579 1580 assert.Len(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria, 2) 1581 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "*") 1582 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("val1")}) 1583 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, Or) 1584 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchColumn, "*") 1585 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchWords, [][]byte{[]byte("val2")}) 1586 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchOperator, Or) 1587 1588 } 1589 1590 func Test_ParseRequest_must_query_string_AND_OR_values(t *testing.T) { 1591 json_body := []byte(`{"query":{ 1592 "bool": {"must" : 1593 {"query_string": { 1594 "analyze_wildcard": true, 1595 "default_field": "*", 1596 "query": "(abc AND abcd) OR eee" 1597 }} 1598 }}}`) 1599 res, _, _, _, err := ParseRequest(json_body, 0, false) 1600 assert.Nil(t, err) 1601 assert.IsType(t, res, &ASTNode{}) 1602 assert.Len(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria, 1) 1603 assert.Len(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria, 2) 1604 1605 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "*") 1606 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("abc")}) 1607 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, Or) 1608 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].MatchFilter.MatchColumn, "*") 1609 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].MatchFilter.MatchWords, [][]byte{[]byte("abcd")}) 1610 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].MatchFilter.MatchOperator, Or) 1611 1612 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "*") 1613 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("eee")}) 1614 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, Or) 1615 1616 } 1617 1618 func Test_ParseRequest_NestedQuery(t *testing.T) { 1619 1620 // (col1=a or col1=b) and col2=c 1621 json_body := []byte(` 1622 { 1623 "query":{ 1624 "bool": { 1625 "must" : [ 1626 {"term" : { "col2" : "c" }}, 1627 {"bool": { 1628 "should" : [ 1629 {"term" : { "col1" : "a" }}, 1630 {"term" : { "col1" : "b" }} 1631 ] 1632 }} 1633 ] 1634 } 1635 } 1636 }`) 1637 res, _, _, _, err := ParseRequest(json_body, 0, false) 1638 assert.Nil(t, err) 1639 assert.IsType(t, res, &ASTNode{}) 1640 assert.Len(t, res.AndFilterCondition.FilterCriteria, 1) 1641 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col2") 1642 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "c") 1643 assert.Len(t, res.AndFilterCondition.NestedNodes, 1) 1644 assert.Len(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria, 2) 1645 assert.Len(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.NestedNodes, 0) 1646 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col1") 1647 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "a") 1648 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col1") 1649 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "b") 1650 } 1651 1652 func Test_parseExists(t *testing.T) { 1653 json_body := []byte(` 1654 { 1655 "query": { 1656 "bool": { 1657 "must": { 1658 "exists": { 1659 "field": "user" 1660 } 1661 } 1662 } 1663 } 1664 }`) 1665 res, _, _, _, err := ParseRequest(json_body, 0, false) 1666 assert.Nil(t, err) 1667 assert.IsType(t, res, &ASTNode{}) 1668 assert.Len(t, res.AndFilterCondition.FilterCriteria, 1) 1669 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "user") 1670 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, IsNotNull) 1671 } 1672 1673 func Test_parseSort(t *testing.T) { 1674 json_body := []byte(` 1675 { 1676 "sort": [ 1677 { 1678 "timestamp": { 1679 "order": "asc", 1680 "unmapped_type": "boolean" 1681 } 1682 } 1683 ] 1684 }`) 1685 _, agg, _, _, err := ParseRequest(json_body, 0, false) 1686 assert.Nil(t, err) 1687 assert.IsType(t, agg, &QueryAggregators{}) 1688 assert.NotNil(t, agg.Sort) 1689 assert.Equal(t, agg.Sort.ColName, "timestamp") 1690 assert.Equal(t, agg.Sort.Ascending, true) 1691 1692 json_body = []byte(` 1693 { 1694 "sort": [ 1695 { 1696 "timestamp": { 1697 "order": "desc", 1698 "unmapped_type": "boolean" 1699 } 1700 } 1701 ] 1702 }`) 1703 _, agg, _, _, err = ParseRequest(json_body, 0, false) 1704 assert.Nil(t, err) 1705 assert.IsType(t, agg, &QueryAggregators{}) 1706 assert.NotNil(t, agg.Sort) 1707 assert.Equal(t, agg.Sort.ColName, "timestamp") 1708 assert.Equal(t, agg.Sort.Ascending, false) 1709 } 1710 1711 func Test_ParseRequest_match_phrase(t *testing.T) { 1712 json_body := []byte(`{ 1713 "query": { 1714 "match_phrase": { 1715 "message": "this is a test" 1716 } 1717 } 1718 }`) 1719 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 1720 assert.Nil(t, err) 1721 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 1722 assert.IsType(t, res, &ASTNode{}) 1723 1724 assert.NotNil(t, res.AndFilterCondition.FilterCriteria) 1725 assert.Len(t, res.AndFilterCondition.FilterCriteria, 1) 1726 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "message") 1727 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, And) 1728 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("this"), []byte("is"), []byte("a"), []byte("test")}) 1729 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchPhrase, []uint8([]byte{0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x74, 0x65, 0x73, 0x74})) 1730 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchType, MATCH_PHRASE) 1731 1732 } 1733 1734 func Test_ParseRequest_must_query_string_free_text(t *testing.T) { 1735 json_body := []byte(`{"query":{ 1736 "bool": {"must" : 1737 {"query_string": { 1738 "analyze_wildcard": true, 1739 "default_field": "*", 1740 "query": "val1" 1741 }} 1742 }}}`) 1743 res, _, _, _, err := ParseRequest(json_body, 0, false) 1744 assert.Nil(t, err) 1745 assert.IsType(t, res, &ASTNode{}) 1746 1747 assert.Len(t, res.AndFilterCondition.FilterCriteria, 1) 1748 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "*") 1749 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("val1")}) 1750 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, Or) 1751 } 1752 1753 func Test_ParseRequest_must_query_string_match_phrase_with_AND(t *testing.T) { 1754 json_body := []byte(`{"query":{ 1755 "bool": {"must" : 1756 {"query_string": { 1757 "analyze_wildcard": true, 1758 "default_field": "*", 1759 "query": "\"val1\" AND \"val2\"" 1760 }} 1761 }}}`) 1762 res, _, _, _, err := ParseRequest(json_body, 0, false) 1763 assert.Nil(t, err) 1764 assert.IsType(t, res, &ASTNode{}) 1765 1766 assert.Len(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria, 2) 1767 1768 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "*") 1769 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("val1")}) 1770 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].MatchFilter.MatchType, MATCH_PHRASE) 1771 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].MatchFilter.MatchColumn, "*") 1772 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].MatchFilter.MatchWords, [][]byte{[]byte("val2")}) 1773 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].MatchFilter.MatchType, MATCH_PHRASE) 1774 } 1775 1776 func Test_ParseRequest_must_query_string_match_phrase_with_OR(t *testing.T) { 1777 json_body := []byte(`{"query":{ 1778 "bool": {"must" : 1779 {"query_string": { 1780 "analyze_wildcard": true, 1781 "default_field": "*", 1782 "query": "\"val1\" OR \"val2\"" 1783 }} 1784 }}}`) 1785 res, _, _, _, err := ParseRequest(json_body, 0, false) 1786 assert.Nil(t, err) 1787 assert.IsType(t, res, &ASTNode{}) 1788 1789 assert.Len(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria, 2) 1790 1791 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "*") 1792 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("val1")}) 1793 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchType, MATCH_PHRASE) 1794 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchColumn, "*") 1795 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchWords, [][]byte{[]byte("val2")}) 1796 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchType, MATCH_PHRASE) 1797 } 1798 1799 func Test_ParseRequest_must_query_string_match_word_with_AND(t *testing.T) { 1800 json_body := []byte(`{"query":{ 1801 "bool": {"must" : 1802 {"query_string": { 1803 "analyze_wildcard": true, 1804 "default_field": "*", 1805 "query": "val1 AND val2" 1806 }} 1807 }}}`) 1808 res, _, _, _, err := ParseRequest(json_body, 0, false) 1809 assert.Nil(t, err) 1810 assert.IsType(t, res, &ASTNode{}) 1811 1812 assert.Len(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria, 2) 1813 1814 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "*") 1815 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("val1")}) 1816 assert.NotEqual(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].MatchFilter.MatchType, MATCH_PHRASE) 1817 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].MatchFilter.MatchColumn, "*") 1818 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].MatchFilter.MatchWords, [][]byte{[]byte("val2")}) 1819 assert.NotEqual(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].MatchFilter.MatchType, MATCH_PHRASE) 1820 } 1821 1822 func Test_ParseRequest_must_query_string_match_word_with_OR(t *testing.T) { 1823 json_body := []byte(`{"query":{ 1824 "bool": {"must" : 1825 {"query_string": { 1826 "analyze_wildcard": true, 1827 "default_field": "*", 1828 "query": "val1 OR val2" 1829 }} 1830 }}}`) 1831 res, _, _, _, err := ParseRequest(json_body, 0, false) 1832 assert.Nil(t, err) 1833 assert.IsType(t, res, &ASTNode{}) 1834 1835 assert.Len(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria, 2) 1836 1837 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "*") 1838 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("val1")}) 1839 assert.NotEqual(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchType, MATCH_PHRASE) 1840 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchColumn, "*") 1841 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchWords, [][]byte{[]byte("val2")}) 1842 assert.NotEqual(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchType, MATCH_PHRASE) 1843 } 1844 1845 func Test_ParseRequest_filter_query_string_col_val(t *testing.T) { 1846 json_body := []byte(`{"query":{ 1847 "bool": {"filter" : 1848 {"query_string": { 1849 "analyze_wildcard": true, 1850 "query": "*:abc" 1851 }} 1852 }}}`) 1853 res, _, _, _, err := ParseRequest(json_body, 0, false) 1854 assert.Nil(t, err) 1855 assert.IsType(t, res, &ASTNode{}) 1856 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "*") 1857 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1858 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "abc") 1859 } 1860 1861 func Test_ParseRequest_must_query_string_col_val_AND_words(t *testing.T) { 1862 json_body := []byte(`{"query":{ 1863 "bool": {"must" : 1864 {"query_string": { 1865 "analyze_wildcard": true, 1866 "default_field": "*", 1867 "query": "col1:val1 AND val2" 1868 }} 1869 }}}`) 1870 res, _, _, _, err := ParseRequest(json_body, 0, false) 1871 assert.Nil(t, err) 1872 assert.IsType(t, res, &ASTNode{}) 1873 assert.Len(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria, 2) 1874 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col1") 1875 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "val1") 1876 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1877 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].MatchFilter.MatchColumn, "*") 1878 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].MatchFilter.MatchWords, [][]byte{[]byte("val2")}) 1879 assert.NotEqual(t, res.AndFilterCondition.NestedNodes[0].AndFilterCondition.FilterCriteria[1].MatchFilter.MatchType, MATCH_PHRASE) 1880 } 1881 1882 func Test_ParseRequest_must_query_string_col_val_OR_words(t *testing.T) { 1883 json_body := []byte(`{"query":{ 1884 "bool": {"must" : 1885 {"query_string": { 1886 "analyze_wildcard": true, 1887 "default_field": "*", 1888 "query": "col1:val1 OR val2" 1889 }} 1890 }}}`) 1891 res, _, _, _, err := ParseRequest(json_body, 0, false) 1892 assert.Nil(t, err) 1893 assert.IsType(t, res, &ASTNode{}) 1894 assert.Len(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria, 2) 1895 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "col1") 1896 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "val1") 1897 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1898 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchColumn, "*") 1899 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchWords, [][]byte{[]byte("val2")}) 1900 assert.NotEqual(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchType, MATCH_PHRASE) 1901 } 1902 func Test_ParseRequest_match_multi_match_no_fields(t *testing.T) { 1903 json_body := []byte(`{ 1904 "query": { 1905 "bool": { 1906 "must": { 1907 "multi_match": { 1908 "query": "quick brown", 1909 "type": "phrase", 1910 "operator": "and" 1911 } 1912 } 1913 } 1914 } 1915 }`) 1916 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 1917 assert.Nil(t, err) 1918 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 1919 assert.IsType(t, res, &ASTNode{}) 1920 1921 assert.NotNil(t, res.AndFilterCondition.FilterCriteria) 1922 assert.Len(t, res.AndFilterCondition.FilterCriteria, 1) 1923 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "*") 1924 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, And) 1925 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("quick"), []byte("brown")}) 1926 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchType, MATCH_PHRASE) 1927 1928 } 1929 1930 func Test_ParseRequest_match_multi_match_with_fields(t *testing.T) { 1931 json_body := []byte(`{ 1932 "query": { 1933 "bool": { 1934 "must": { 1935 "multi_match": { 1936 "query": "quick brown", 1937 "type": "phrase", 1938 "operator": "and", 1939 "fields": [ "subject", "message" ] 1940 } 1941 } 1942 } 1943 } 1944 }`) 1945 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 1946 assert.Nil(t, err) 1947 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 1948 assert.IsType(t, res, &ASTNode{}) 1949 1950 assert.NotNil(t, res.AndFilterCondition.FilterCriteria) 1951 assert.Len(t, res.AndFilterCondition.FilterCriteria, 2) 1952 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "subject") 1953 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, And) 1954 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("quick"), []byte("brown")}) 1955 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].MatchFilter.MatchType, MATCH_PHRASE) 1956 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].MatchFilter.MatchColumn, "message") 1957 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].MatchFilter.MatchOperator, And) 1958 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].MatchFilter.MatchWords, [][]byte{[]byte("quick"), []byte("brown")}) 1959 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].MatchFilter.MatchType, MATCH_PHRASE) 1960 1961 } 1962 1963 func Test_ParseRequest_match_multi_match_with_fields_phrase_prefix(t *testing.T) { 1964 json_body := []byte(`{ 1965 "query": { 1966 "bool": { 1967 "must": { 1968 "multi_match": { 1969 "query": "quick brown f", 1970 "type": "phrase_prefix", 1971 "operator": "and", 1972 "fields": [ "subject", "message" ] 1973 } 1974 } 1975 } 1976 } 1977 }`) 1978 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 1979 assert.Nil(t, err) 1980 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 1981 assert.IsType(t, res, &ASTNode{}) 1982 1983 assert.NotNil(t, res.AndFilterCondition.FilterCriteria) 1984 assert.Len(t, res.AndFilterCondition.FilterCriteria, 2) 1985 1986 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "subject") 1987 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "quick brown f.*") 1988 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 1989 1990 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "message") 1991 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "quick brown f.*") 1992 assert.Equal(t, res.AndFilterCondition.FilterCriteria[1].ExpressionFilter.FilterOperator, Equals) 1993 1994 } 1995 1996 func Test_ParseRequest_match_multi_match_no_fields_phrase_prefix(t *testing.T) { 1997 json_body := []byte(`{ 1998 "query": { 1999 "bool": { 2000 "must": { 2001 "multi_match": { 2002 "query": "quick brown f", 2003 "type": "phrase_prefix", 2004 "operator": "and" 2005 } 2006 } 2007 } 2008 } 2009 }`) 2010 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 2011 assert.Nil(t, err) 2012 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 2013 assert.IsType(t, res, &ASTNode{}) 2014 2015 assert.NotNil(t, res.AndFilterCondition.FilterCriteria) 2016 assert.Len(t, res.AndFilterCondition.FilterCriteria, 1) 2017 2018 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.LeftInput.Expression.LeftInput.ColumnName, "*") 2019 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.RightInput.Expression.LeftInput.ColumnValue.StringVal, "quick brown f.*") 2020 assert.Equal(t, res.AndFilterCondition.FilterCriteria[0].ExpressionFilter.FilterOperator, Equals) 2021 2022 } 2023 2024 func Test_ParseRequest_match_multi_best_fields(t *testing.T) { 2025 json_body := []byte(`{ 2026 "query": { 2027 "bool": { 2028 "must": { 2029 "multi_match": { 2030 "type": "best_fields", 2031 "query": "match words", 2032 "lenient": true 2033 } 2034 } 2035 } 2036 } 2037 }`) 2038 res, aggs, _, _, err := ParseRequest(json_body, 0, false) 2039 assert.Nil(t, err) 2040 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 2041 assert.IsType(t, res, &ASTNode{}) 2042 2043 log.Infof("result %+v", res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0]) 2044 assert.NotNil(t, res.AndFilterCondition.NestedNodes) 2045 assert.Len(t, res.AndFilterCondition.NestedNodes, 1) 2046 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "*") 2047 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, Or) 2048 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("match"), []byte("words")}) 2049 assert.NotEqual(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchType, MATCH_PHRASE) 2050 2051 json_body = []byte(`{ 2052 "query": { 2053 "bool": { 2054 "must": { 2055 "multi_match" : { 2056 "query": "brown fox", 2057 "type": "best_fields", 2058 "fields": [ "subject", "message" ], 2059 "tie_breaker": 0.3 2060 } 2061 } 2062 } 2063 } 2064 }`) 2065 res, aggs, _, _, err = ParseRequest(json_body, 0, false) 2066 assert.Nil(t, err) 2067 assert.Equal(t, aggs, structs.InitDefaultQueryAggregations()) 2068 assert.IsType(t, res, &ASTNode{}) 2069 assert.NotNil(t, res.AndFilterCondition.NestedNodes) 2070 assert.Len(t, res.AndFilterCondition.NestedNodes, 1) 2071 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchColumn, "subject") 2072 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchOperator, Or) 2073 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchWords, [][]byte{[]byte("brown"), []byte("fox")}) 2074 assert.NotEqual(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[0].MatchFilter.MatchType, MATCH_PHRASE) 2075 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchColumn, "message") 2076 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchOperator, Or) 2077 assert.Equal(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchWords, [][]byte{[]byte("brown"), []byte("fox")}) 2078 assert.NotEqual(t, res.AndFilterCondition.NestedNodes[0].OrFilterCondition.FilterCriteria[1].MatchFilter.MatchType, MATCH_PHRASE) 2079 }