t/unit/frontend/parser_test.c

   1 /*
   2  * SysDB - t/unit/frontend/parser_test.c
   3  * Copyright (C) 2013-2015 Sebastian 'tokkee' Harl <sh@tokkee.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  17  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  18  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
  19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #if HAVE_CONFIG_H
  29 #       include "config.h"
  30 #endif
  31
  32 #include "frontend/connection.h"
  33 #include "frontend/parser.h"
  34 #include "core/store-private.h"
  35 #include "core/object.h"
  36 #include "testutils.h"
  37
  38 #include <check.h>
  39 #include <limits.h>
  40
  41 /*
  42  * tests
  43  */
  44
  45 struct {
  46         const char *query;
  47         int len;
  48         int expected;
  49         sdb_conn_state_t expected_cmd;
  50 } parse_data[] = {
  51         /* empty commands */
  52         { NULL,                  -1, -1, 0 },
  53         { "",                    -1,  0, 0 },
  54         { ";",                   -1,  0, 0 },
  55         { ";;",                  -1,  0, 0 },
  56
  57         /* FETCH commands */
  58         { "FETCH host 'host'",   -1,  1, SDB_CONNECTION_FETCH  },
  59         { "FETCH host 'host' FILTER "
  60           "age > 60s",           -1,  1, SDB_CONNECTION_FETCH  },
  61         { "FETCH service "
  62           "'host'.'service'",    -1,  1, SDB_CONNECTION_FETCH  },
  63         { "FETCH metric "
  64           "'host'.'metric'",     -1,  1, SDB_CONNECTION_FETCH  },
  65
  66         /* LIST commands */
  67         { "LIST hosts",          -1,  1, SDB_CONNECTION_LIST   },
  68         { "LIST hosts -- foo",   -1,  1, SDB_CONNECTION_LIST   },
  69         { "LIST hosts;",         -1,  1, SDB_CONNECTION_LIST   },
  70         { "LIST hosts; INVALID", 11,  1, SDB_CONNECTION_LIST   },
  71         { "LIST hosts FILTER "
  72           "age > 60s",           -1,  1, SDB_CONNECTION_LIST   },
  73         { "LIST services",       -1,  1, SDB_CONNECTION_LIST   },
  74         { "LIST services FILTER "
  75           "age > 60s",           -1,  1, SDB_CONNECTION_LIST   },
  76         { "LIST metrics",        -1,  1, SDB_CONNECTION_LIST   },
  77         { "LIST metrics FILTER "
  78           "age > 60s",           -1,  1, SDB_CONNECTION_LIST   },
  79
  80         /* LOOKUP commands */
  81         { "LOOKUP hosts",        -1,  1, SDB_CONNECTION_LOOKUP },
  82         { "LOOKUP hosts MATCHING "
  83           "name = 'host'",       -1,  1, SDB_CONNECTION_LOOKUP },
  84         { "LOOKUP hosts MATCHING NOT "
  85           "name = 'host'",       -1,  1, SDB_CONNECTION_LOOKUP },
  86         { "LOOKUP hosts MATCHING "
  87           "name =~ 'p' AND "
  88           "ANY service =~ 'p'",  -1,  1, SDB_CONNECTION_LOOKUP },
  89         { "LOOKUP hosts MATCHING NOT "
  90           "name =~ 'p' AND "
  91           "ANY service =~ 'p'",  -1,  1, SDB_CONNECTION_LOOKUP },
  92         { "LOOKUP hosts MATCHING "
  93           "name =~ 'p' AND "
  94           "ANY service =~ 'p' OR "
  95           "ANY service =~ 'r'",  -1,  1, SDB_CONNECTION_LOOKUP },
  96         { "LOOKUP hosts MATCHING NOT "
  97           "name =~ 'p' AND "
  98           "ANY service =~ 'p' OR "
  99           "ANY service =~ 'r'",  -1,  1, SDB_CONNECTION_LOOKUP },
 100         { "LOOKUP hosts MATCHING "
 101           "name =~ 'p' "
 102           "FILTER age > 1D",    -1,   1, SDB_CONNECTION_LOOKUP },
 103         { "LOOKUP hosts MATCHING "
 104           "name =~ 'p' "
 105           "FILTER age > 1D AND "
 106           "interval < 240s" ,   -1,   1, SDB_CONNECTION_LOOKUP },
 107         { "LOOKUP hosts MATCHING "
 108           "name =~ 'p' "
 109           "FILTER NOT age>1D",  -1,   1, SDB_CONNECTION_LOOKUP },
 110         { "LOOKUP hosts MATCHING "
 111           "name =~ 'p' "
 112           "FILTER age>"
 113           "interval",           -1,   1, SDB_CONNECTION_LOOKUP },
 114         { "LOOKUP hosts MATCHING "
 115           "host.name =~ 'p'",   -1,   1, SDB_CONNECTION_LOOKUP },
 116         { "LOOKUP services",    -1,   1, SDB_CONNECTION_LOOKUP },
 117         { "LOOKUP services MATCHING ANY "
 118           "attribute =~ 'a'",   -1,   1, SDB_CONNECTION_LOOKUP },
 119         { "LOOKUP services MATCHING "
 120           "host.name = 'p'",    -1,   1, SDB_CONNECTION_LOOKUP },
 121         { "LOOKUP services MATCHING "
 122           "service.name = 'p'", -1,   1, SDB_CONNECTION_LOOKUP },
 123         { "LOOKUP metrics",     -1,   1, SDB_CONNECTION_LOOKUP },
 124         { "LOOKUP metrics MATCHING ANY "
 125           "attribute =~ 'a'",   -1,   1, SDB_CONNECTION_LOOKUP },
 126         { "LOOKUP metrics MATCHING "
 127           "host.name = 'p'",    -1,   1, SDB_CONNECTION_LOOKUP },
 128         { "LOOKUP metrics MATCHING "
 129           "metric.name = 'p'",  -1,   1, SDB_CONNECTION_LOOKUP },
 130
 131         /* TIMESERIES commands */
 132         { "TIMESERIES 'host'.'metric' "
 133           "START 2014-01-01 "
 134           "END 2014-12-31 "
 135           "23:59:59",            -1,  1, SDB_CONNECTION_TIMESERIES },
 136         { "TIMESERIES 'host'.'metric' "
 137           "START 2014-02-02 "
 138           "14:02",               -1,  1, SDB_CONNECTION_TIMESERIES },
 139         { "TIMESERIES 'host'.'metric' "
 140           "END 2014-02-02",      -1,  1, SDB_CONNECTION_TIMESERIES },
 141         { "TIMESERIES "
 142           "'host'.'metric'",     -1,  1, SDB_CONNECTION_TIMESERIES },
 143
 144         /* STORE commands */
 145         { "STORE host 'host'",   -1,  1, SDB_CONNECTION_STORE_HOST },
 146         { "STORE host 'host' "
 147           "LAST UPDATE "
 148           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_HOST },
 149         { "STORE host attribute "
 150           "'host'.'key' 123",    -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 151         { "STORE host attribute "
 152           "'host'.'key' 123 "
 153           "LAST UPDATE "
 154           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 155         { "STORE service "
 156           "'host'.'svc'",        -1,  1, SDB_CONNECTION_STORE_SERVICE },
 157         { "STORE service "
 158           "'host'.'svc' "
 159           "LAST UPDATE "
 160           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_SERVICE },
 161         { "STORE service attribute "
 162           "'host'.'svc'.'key' "
 163           "123",                 -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 164         { "STORE service attribute "
 165           "'host'.'svc'.'key' "
 166           "123 "
 167           "LAST UPDATE "
 168           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 169         { "STORE metric "
 170           "'host'.'metric'",     -1,  1, SDB_CONNECTION_STORE_METRIC },
 171         { "STORE metric "
 172           "'host'.'metric' "
 173           "LAST UPDATE "
 174           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_METRIC },
 175         { "STORE metric "
 176           "'host'.'metric' "
 177           "STORE 'typ' 'id' "
 178           "LAST UPDATE "
 179           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_METRIC },
 180         { "STORE metric attribute "
 181           "'host'.'metric'.'key' "
 182           "123",                 -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 183         { "STORE metric attribute "
 184           "'host'.'metric'.'key' "
 185           "123 "
 186           "LAST UPDATE "
 187           "2015-02-01",          -1,  1, SDB_CONNECTION_STORE_ATTRIBUTE },
 188
 189         /* string constants */
 190         { "LOOKUP hosts MATCHING "
 191           "name = ''''",         -1,  1, SDB_CONNECTION_LOOKUP },
 192         { "LOOKUP hosts MATCHING "
 193           "name = '''foo'",      -1,  1, SDB_CONNECTION_LOOKUP },
 194         { "LOOKUP hosts MATCHING "
 195           "name = 'f''oo'",      -1,  1, SDB_CONNECTION_LOOKUP },
 196         { "LOOKUP hosts MATCHING "
 197           "name = 'foo'''",      -1,  1, SDB_CONNECTION_LOOKUP },
 198         { "LOOKUP hosts MATCHING "
 199           "name = '''",          -1, -1, 0 },
 200
 201         /* numeric constants */
 202         { "LOOKUP hosts MATCHING "
 203           "attribute['foo'] = "
 204           "1234",                -1,  1, SDB_CONNECTION_LOOKUP },
 205         { "LOOKUP hosts MATCHING "
 206           "attribute['foo'] != "
 207           "+234",                -1,  1, SDB_CONNECTION_LOOKUP },
 208         { "LOOKUP hosts MATCHING "
 209           "attribute['foo'] < "
 210           "-234",                -1,  1, SDB_CONNECTION_LOOKUP },
 211         { "LOOKUP hosts MATCHING "
 212           "attribute['foo'] > "
 213           "12.4",                -1,  1, SDB_CONNECTION_LOOKUP },
 214         { "LOOKUP hosts MATCHING "
 215           "attribute['foo'] <= "
 216           "12. + .3",            -1,  1, SDB_CONNECTION_LOOKUP },
 217         { "LOOKUP hosts MATCHING "
 218           "attribute['foo'] <= "
 219           "'f' || 'oo'",         -1,  1, SDB_CONNECTION_LOOKUP },
 220         { "LOOKUP hosts MATCHING "
 221           "attribute['foo'] >= "
 222           ".4",                  -1,  1, SDB_CONNECTION_LOOKUP },
 223         { "LOOKUP hosts MATCHING "
 224           "attribute['foo'] = "
 225           "+12e3",               -1,  1, SDB_CONNECTION_LOOKUP },
 226         { "LOOKUP hosts MATCHING "
 227           "attribute['foo'] = "
 228           "+12e-3",              -1,  1, SDB_CONNECTION_LOOKUP },
 229         { "LOOKUP hosts MATCHING "
 230           "attribute['foo'] = "
 231           "-12e+3",              -1,  1, SDB_CONNECTION_LOOKUP },
 232
 233         /* date, time, interval constants */
 234         { "LOOKUP hosts MATCHING "
 235           "attribute['foo'] = "
 236           "1 Y 42D",             -1,  1, SDB_CONNECTION_LOOKUP },
 237         { "LOOKUP hosts MATCHING "
 238           "attribute['foo'] = "
 239           "1s 42D",              -1,  1, SDB_CONNECTION_LOOKUP },
 240         /*
 241          * TODO: Something like 1Y42D should work as well but it doesn't since
 242          * the scanner will tokenize it into {digit}{identifier} :-/
 243          *
 244         { "LOOKUP hosts MATCHING "
 245           "attribute['foo'] = "
 246           "1Y42D",               -1,  1, SDB_CONNECTION_LOOKUP },
 247          */
 248
 249         /* array constants */
 250         { "LOOKUP hosts MATCHING "
 251           "backend = ['foo']",   -1,  1, SDB_CONNECTION_LOOKUP },
 252         { "LOOKUP hosts MATCHING "
 253           "backend = ['a','b']", -1,  1, SDB_CONNECTION_LOOKUP },
 254
 255         /* array iteration */
 256         { "LOOKUP hosts MATCHING "
 257           "'foo' IN backend",   -1,   1, SDB_CONNECTION_LOOKUP },
 258         { "LOOKUP hosts MATCHING 'foo' "
 259           "NOT IN backend",   -1,   1, SDB_CONNECTION_LOOKUP },
 260         { "LOOKUP hosts MATCHING "
 261           "['foo','bar'] "
 262           "IN backend ",        -1,   1, SDB_CONNECTION_LOOKUP },
 263         /* attribute type is unknown */
 264         { "LOOKUP hosts MATCHING "
 265           "attribute['backend'] "
 266           "IN backend ",        -1,   1, SDB_CONNECTION_LOOKUP },
 267         /* type mismatch */
 268         { "LOOKUP hosts MATCHING "
 269           "1 IN backend ",      -1,  -1, 0 },
 270         { "LOOKUP hosts MATCHING "
 271           "1 NOT IN backend ",  -1,  -1, 0 },
 272         { "LOOKUP hosts MATCHING "
 273           "ANY backend < 'b'",  -1,   1, SDB_CONNECTION_LOOKUP },
 274         { "LOOKUP hosts MATCHING "
 275           "ANY backend <= 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 276         { "LOOKUP hosts MATCHING "
 277           "ANY backend = 'b'",  -1,   1, SDB_CONNECTION_LOOKUP },
 278         { "LOOKUP hosts MATCHING "
 279           "ANY backend != 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 280         { "LOOKUP hosts MATCHING "
 281           "ANY backend >= 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 282         { "LOOKUP hosts MATCHING "
 283           "ANY backend > 'b'",  -1,   1, SDB_CONNECTION_LOOKUP },
 284         { "LOOKUP hosts MATCHING "
 285           "ANY backend =~ 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 286         { "LOOKUP hosts MATCHING "
 287           "ANY backend !~ 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 288         { "LOOKUP hosts MATCHING "
 289           "ALL backend < 'b'",  -1,   1, SDB_CONNECTION_LOOKUP },
 290         { "LOOKUP hosts MATCHING "
 291           "ALL backend <= 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 292         { "LOOKUP hosts MATCHING "
 293           "ALL backend = 'b'",  -1,   1, SDB_CONNECTION_LOOKUP },
 294         { "LOOKUP hosts MATCHING "
 295           "ALL backend != 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 296         { "LOOKUP hosts MATCHING "
 297           "ALL backend >= 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 298         { "LOOKUP hosts MATCHING "
 299           "ALL backend > 'b'",  -1,   1, SDB_CONNECTION_LOOKUP },
 300         { "LOOKUP hosts MATCHING "
 301           "ALL backend =~ 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 302         { "LOOKUP hosts MATCHING "
 303           "ALL backend !~ 'b'", -1,   1, SDB_CONNECTION_LOOKUP },
 304         /* attribute type is unknown */
 305         { "LOOKUP hosts MATCHING "
 306           "ANY backend = attribute['backend']",
 307                                 -1,   1, SDB_CONNECTION_LOOKUP },
 308         /* type mismatch */
 309         { "LOOKUP hosts MATCHING "
 310           "ANY backend = 1",    -1,  -1, 0 },
 311
 312         /* valid operand types */
 313         { "LOOKUP hosts MATCHING "
 314           "age * 1 > 0s",        -1,  1, SDB_CONNECTION_LOOKUP },
 315         { "LOOKUP hosts MATCHING "
 316           "age / 1 > 0s",        -1,  1, SDB_CONNECTION_LOOKUP },
 317         { "LOOKUP hosts MATCHING "
 318           "name > ''",           -1,  1, SDB_CONNECTION_LOOKUP },
 319         { "LOOKUP hosts MATCHING "
 320           "name >= ''",          -1,  1, SDB_CONNECTION_LOOKUP },
 321         { "LOOKUP hosts MATCHING "
 322           "name != ''",          -1,  1, SDB_CONNECTION_LOOKUP },
 323         { "LOOKUP hosts MATCHING "
 324           "name = ''",           -1,  1, SDB_CONNECTION_LOOKUP },
 325         { "LOOKUP hosts MATCHING "
 326           "name <= ''",          -1,  1, SDB_CONNECTION_LOOKUP },
 327         { "LOOKUP hosts MATCHING "
 328           "name < ''",           -1,  1, SDB_CONNECTION_LOOKUP },
 329
 330         /* NULL */
 331         { "LOOKUP hosts MATCHING "
 332           "attribute['foo'] "
 333           "IS NULL",             -1,  1, SDB_CONNECTION_LOOKUP },
 334         { "LOOKUP hosts MATCHING "
 335           "attribute['foo'] "
 336           "IS NOT NULL",         -1,  1, SDB_CONNECTION_LOOKUP },
 337         { "LOOKUP hosts MATCHING "
 338           "NOT attribute['foo'] "
 339           "IS NULL",             -1,  1, SDB_CONNECTION_LOOKUP },
 340         { "LOOKUP hosts MATCHING "
 341           "ANY service IS NULL", -1, -1, 0 },
 342
 343         /* invalid numeric constants */
 344         { "LOOKUP hosts MATCHING "
 345           "attribute['foo'] = "
 346           "+-12e+3",             -1, -1, 0 },
 347         { "LOOKUP hosts MATCHING "
 348           "attribute['foo'] = "
 349           "-12e-+3",             -1, -1, 0 },
 350         { "LOOKUP hosts MATCHING "
 351           "attribute['foo'] = "
 352           "e+3",                 -1, -1, 0 },
 353         { "LOOKUP hosts MATCHING "
 354           "attribute['foo'] = "
 355           "3e",                  -1, -1, 0 },
 356         /* following SQL standard, we don't support hex numbers */
 357         { "LOOKUP hosts MATCHING "
 358           "attribute['foo'] = "
 359           "0x12",                -1, -1, 0 },
 360
 361         /* invalid expressions */
 362         { "LOOKUP hosts MATCHING "
 363           "attribute['foo'] = "
 364           "1.23 + 'foo'",        -1, -1, 0 },
 365         { "LOOKUP hosts MATCHING "
 366           "attr['foo'] = 1.23",  -1, -1, 0 },
 367         { "LOOKUP hosts MATCHING "
 368           "attr['foo'] IS NULL", -1, -1, 0 },
 369
 370         /* type mismatches */
 371         { "LOOKUP hosts MATCHING "
 372           "age > 0",             -1, -1, 0 },
 373         { "LOOKUP hosts MATCHING "
 374           "age >= 0",            -1, -1, 0 },
 375         { "LOOKUP hosts MATCHING "
 376           "age = 0",             -1, -1, 0 },
 377         { "LOOKUP hosts MATCHING "
 378           "age != 0",            -1, -1, 0 },
 379         { "LOOKUP hosts MATCHING "
 380           "age <= 0",            -1, -1, 0 },
 381         { "LOOKUP hosts MATCHING "
 382           "age < 0",             -1, -1, 0 },
 383         { "LOOKUP hosts MATCHING "
 384           "age + 1 > 0s",        -1, -1, 0 },
 385         { "LOOKUP hosts MATCHING "
 386           "age - 1 > 0s",        -1, -1, 0 },
 387         /* datetime <mul/div> integer is allowed */
 388         { "LOOKUP hosts MATCHING "
 389           "age || 1 > 0s",       -1, -1, 0 },
 390         { "LOOKUP hosts MATCHING "
 391           "name + 1 = ''",       -1, -1, 0 },
 392         { "LOOKUP hosts MATCHING "
 393           "name - 1 = ''",       -1, -1, 0 },
 394         { "LOOKUP hosts MATCHING "
 395           "name * 1 = ''",       -1, -1, 0 },
 396         { "LOOKUP hosts MATCHING "
 397           "name / 1 = ''",       -1, -1, 0 },
 398         { "LOOKUP hosts MATCHING "
 399           "name % 1 = ''",       -1, -1, 0 },
 400
 401         /* comments */
 402         { "/* some comment */",  -1,  0, 0 },
 403         { "-- another comment",  -1,  0, 0 },
 404
 405         /* syntax errors */
 406         { "INVALID",             -1, -1, 0 },
 407         { "FETCH host",          -1, -1, 0 },
 408         { "FETCH 'host'",        -1, -1, 0 },
 409         { "LIST hosts; INVALID", -1, -1, 0 },
 410         { "/* some incomplete",  -1, -1, 0 },
 411
 412         /* invalid LIST commands */
 413         { "LIST",                -1, -1, 0 },
 414         { "LIST foo",            -1, -1, 0 },
 415         { "LIST hosts MATCHING "
 416           "name = 'host'",       -1, -1, 0 },
 417         { "LIST foo FILTER "
 418           "age > 60s",           -1, -1, 0 },
 419
 420         /* invalid FETCH commands */
 421         { "FETCH host 'host' MATCHING "
 422           "name = 'host'",       -1, -1, 0 },
 423         { "FETCH service 'host'",-1, -1, 0 },
 424         { "FETCH metric 'host'", -1, -1, 0 },
 425         { "FETCH host "
 426           "'host'.'localhost'",  -1, -1, 0 },
 427         { "FETCH foo 'host'",    -1, -1, 0 },
 428         { "FETCH foo 'host' FILTER "
 429           "age > 60s",           -1, -1, 0 },
 430
 431         /* invalid LOOKUP commands */
 432         { "LOOKUP foo",          -1, -1, 0 },
 433         { "LOOKUP foo MATCHING "
 434           "name = 'host'",       -1, -1, 0 },
 435         { "LOOKUP foo FILTER "
 436           "age > 60s",           -1, -1, 0 },
 437         { "LOOKUP foo MATCHING "
 438           "name = 'host' FILTER "
 439           "age > 60s",           -1, -1, 0 },
 440         { "LOOKUP hosts MATCHING "
 441           "attribute['foo'] <= "
 442           "f || 'oo'",           -1, -1, 0 },
 443         { "LOOKUP hosts MATCHING "
 444           "attribute['foo'] <= "
 445           "'f' || oo",           -1, -1, 0 },
 446         { "LOOKUP hosts MATCHING "
 447           "ANY host = 'host'",   -1, -1, 0 },
 448         { "LOOKUP hosts MATCHING "
 449           "service.name = 's'",  -1, -1, 0 },
 450         { "LOOKUP services MATCHING "
 451           "ANY host = 'host'",   -1, -1, 0 },
 452         { "LOOKUP services MATCHING "
 453           "ANY service = 'svc'", -1, -1, 0 },
 454         { "LOOKUP services MATCHING "
 455           "ANY metric = 'm'",    -1, -1, 0 },
 456         { "LOOKUP services MATCHING "
 457           "metric.name = 'm'",   -1, -1, 0 },
 458         { "LOOKUP metrics MATCHING "
 459           "ANY host = 'host'",   -1, -1, 0 },
 460         { "LOOKUP metrics MATCHING "
 461           "ANY service = 'svc'", -1, -1, 0 },
 462         { "LOOKUP metrics MATCHING "
 463           "ANY metric = 'm'",    -1, -1, 0 },
 464         { "LOOKUP metrics MATCHING "
 465           "service.name = 'm'",  -1, -1, 0 },
 466
 467         /* invalid STORE commands */
 468         { "STORE host "
 469           "'obj'.'host'",        -1, -1, 0 },
 470         { "STORE host attribute "
 471           ".'key' 123",          -1, -1, 0 },
 472         { "STORE host attribute "
 473           "'o'.'h'.'key' 123",   -1, -1, 0 },
 474         { "STORE service 'svc'", -1, -1, 0 },
 475         { "STORE service "
 476           "'host'.'svc' "
 477           "STORE 'typ' 'id' "
 478           "LAST UPDATE "
 479           "2015-02-01",          -1, -1, 0 },
 480         { "STORE service attribute "
 481           "'svc'.'key' 123",     -1, -1, 0 },
 482         { "STORE metric 'm'",    -1, -1, 0 },
 483         { "STORE metric "
 484           "'host'.'metric' "
 485           "STORE 'typ'.'id' "
 486           "LAST UPDATE "
 487           "2015-02-01",          -1, -1, 0 },
 488         { "STORE metric attribute "
 489           "'metric'.'key' 123",  -1, -1, 0 },
 490 };
 491
 492 START_TEST(test_parse)
 493 {
 494         sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
 495         sdb_llist_t *check;
 496         sdb_object_t *obj;
 497         _Bool ok;
 498
 499         check = sdb_fe_parse(parse_data[_i].query,
 500                         parse_data[_i].len, errbuf);
 501         if (parse_data[_i].expected < 0)
 502                 ok = check == 0;
 503         else
 504                 ok = sdb_llist_len(check) == (size_t)parse_data[_i].expected;
 505
 506         fail_unless(ok, "sdb_fe_parse(%s) = %p (len: %zu); expected: %d "
 507                         "(parser error: %s)", parse_data[_i].query, check,
 508                         sdb_llist_len(check), parse_data[_i].expected,
 509                         sdb_strbuf_string(errbuf));
 510
 511         if (! check) {
 512                 sdb_strbuf_destroy(errbuf);
 513                 return;
 514         }
 515
 516         if ((! parse_data[_i].expected_cmd)
 517                         || (parse_data[_i].expected <= 0)) {
 518                 sdb_llist_destroy(check);
 519                 sdb_strbuf_destroy(errbuf);
 520                 return;
 521         }
 522
 523         obj = sdb_llist_get(check, 0);
 524         fail_unless(SDB_CONN_NODE(obj)->cmd == parse_data[_i].expected_cmd,
 525                         "sdb_fe_parse(%s)->cmd = %i; expected: %d",
 526                         parse_data[_i].query, SDB_CONN_NODE(obj)->cmd,
 527                         parse_data[_i].expected_cmd);
 528
 529         sdb_object_deref(obj);
 530         sdb_llist_destroy(check);
 531         sdb_strbuf_destroy(errbuf);
 532 }
 533 END_TEST
 534
 535 struct {
 536         const char *expr;
 537         int len;
 538         int expected;
 539 } parse_matcher_data[] = {
 540         /* empty expressions */
 541         { NULL,                           -1, -1 },
 542         { "",                             -1, -1 },
 543
 544         /* match hosts by name */
 545         { "name < 'localhost'",           -1,  MATCHER_LT },
 546         { "name <= 'localhost'",          -1,  MATCHER_LE },
 547         { "name = 'localhost'",           -1,  MATCHER_EQ },
 548         { "name != 'localhost'",          -1,  MATCHER_NE },
 549         { "name >= 'localhost'",          -1,  MATCHER_GE },
 550         { "name > 'localhost'",           -1,  MATCHER_GT },
 551         { "name =~ 'host'",               -1,  MATCHER_REGEX },
 552         { "name !~ 'host'",               -1,  MATCHER_NREGEX },
 553         { "name = 'localhost' -- foo",    -1,  MATCHER_EQ },
 554         { "name = 'host' <garbage>",      13,  MATCHER_EQ },
 555         { "name &^ 'localhost'",          -1,  -1 },
 556         /* match by backend */
 557         { "ANY backend < 'be'",           -1,  MATCHER_ANY },
 558         { "ANY backend <= 'be'",          -1,  MATCHER_ANY },
 559         { "ANY backend = 'be'",           -1,  MATCHER_ANY },
 560         { "ANY backend != 'be'",          -1,  MATCHER_ANY },
 561         { "ANY backend >= 'be'",          -1,  MATCHER_ANY },
 562         { "ANY backend > 'be'",           -1,  MATCHER_ANY },
 563         { "ALL backend < 'be'",           -1,  MATCHER_ALL },
 564         { "ALL backend <= 'be'",          -1,  MATCHER_ALL },
 565         { "ALL backend = 'be'",           -1,  MATCHER_ALL },
 566         { "ALL backend != 'be'",          -1,  MATCHER_ALL },
 567         { "ALL backend >= 'be'",          -1,  MATCHER_ALL },
 568         { "ALL backend > 'be'",           -1,  MATCHER_ALL },
 569         { "ANY backend &^ 'be'",          -1,  -1 },
 570         /* match hosts by service */
 571         { "ANY service < 'name'",         -1,  MATCHER_ANY },
 572         { "ANY service <= 'name'",        -1,  MATCHER_ANY },
 573         { "ANY service = 'name'",         -1,  MATCHER_ANY },
 574         { "ANY service != 'name'",        -1,  MATCHER_ANY },
 575         { "ANY service >= 'name'",        -1,  MATCHER_ANY },
 576         { "ANY service > 'name'",         -1,  MATCHER_ANY },
 577         { "ANY service =~ 'pattern'",     -1,  MATCHER_ANY },
 578         { "ANY service !~ 'pattern'",     -1,  MATCHER_ANY },
 579         { "ANY service &^ 'name'",        -1,  -1 },
 580         { "ALL service < 'name'",         -1,  MATCHER_ALL },
 581         { "ALL service <= 'name'",        -1,  MATCHER_ALL },
 582         { "ALL service = 'name'",         -1,  MATCHER_ALL },
 583         { "ALL service != 'name'",        -1,  MATCHER_ALL },
 584         { "ALL service >= 'name'",        -1,  MATCHER_ALL },
 585         { "ALL service > 'name'",         -1,  MATCHER_ALL },
 586         { "ALL service =~ 'pattern'",     -1,  MATCHER_ALL },
 587         { "ALL service !~ 'pattern'",     -1,  MATCHER_ALL },
 588         { "ALL service &^ 'name'",        -1,  -1 },
 589         /* match hosts by metric */
 590         { "ANY metric < 'name'",          -1,  MATCHER_ANY },
 591         { "ANY metric <= 'name'",         -1,  MATCHER_ANY },
 592         { "ANY metric = 'name'",          -1,  MATCHER_ANY },
 593         { "ANY metric != 'name'",         -1,  MATCHER_ANY },
 594         { "ANY metric >= 'name'",         -1,  MATCHER_ANY },
 595         { "ANY metric > 'name'",          -1,  MATCHER_ANY },
 596         { "ANY metric =~ 'pattern'",      -1,  MATCHER_ANY },
 597         { "ANY metric !~ 'pattern'",      -1,  MATCHER_ANY },
 598         { "ANY metric &^ 'pattern'",      -1,  -1 },
 599         { "ALL metric < 'name'",          -1,  MATCHER_ALL },
 600         { "ALL metric <= 'name'",         -1,  MATCHER_ALL },
 601         { "ALL metric = 'name'",          -1,  MATCHER_ALL },
 602         { "ALL metric != 'name'",         -1,  MATCHER_ALL },
 603         { "ALL metric >= 'name'",         -1,  MATCHER_ALL },
 604         { "ALL metric > 'name'",          -1,  MATCHER_ALL },
 605         { "ALL metric =~ 'pattern'",      -1,  MATCHER_ALL },
 606         { "ALL metric !~ 'pattern'",      -1,  MATCHER_ALL },
 607         { "ALL metric &^ 'pattern'",      -1,  -1 },
 608         /* match hosts by attribute */
 609         { "ANY attribute < 'name'",       -1,  MATCHER_ANY },
 610         { "ANY attribute <= 'name'",      -1,  MATCHER_ANY },
 611         { "ANY attribute = 'name'",       -1,  MATCHER_ANY },
 612         { "ANY attribute != 'name'",      -1,  MATCHER_ANY },
 613         { "ANY attribute >= 'name'",      -1,  MATCHER_ANY },
 614         { "ANY attribute > 'name'",       -1,  MATCHER_ANY },
 615         { "ANY attribute =~ 'pattern'",   -1,  MATCHER_ANY },
 616         { "ANY attribute !~ 'pattern'",   -1,  MATCHER_ANY },
 617         { "ANY attribute &^ 'pattern'",   -1,  -1 },
 618         { "ALL attribute < 'name'",       -1,  MATCHER_ALL },
 619         { "ALL attribute <= 'name'",      -1,  MATCHER_ALL },
 620         { "ALL attribute = 'name'",       -1,  MATCHER_ALL },
 621         { "ALL attribute != 'name'",      -1,  MATCHER_ALL },
 622         { "ALL attribute >= 'name'",      -1,  MATCHER_ALL },
 623         { "ALL attribute > 'name'",       -1,  MATCHER_ALL },
 624         { "ALL attribute =~ 'pattern'",   -1,  MATCHER_ALL },
 625         { "ALL attribute !~ 'pattern'",   -1,  MATCHER_ALL },
 626         { "ALL attribute &^ 'pattern'",   -1,  -1 },
 627         /* composite expressions */
 628         { "name =~ 'pattern' AND "
 629           "ANY service =~ 'pattern'",     -1,  MATCHER_AND },
 630         { "name =~ 'pattern' OR "
 631           "ANY service =~ 'pattern'",     -1,  MATCHER_OR },
 632         { "NOT name = 'host'",            -1,  MATCHER_NOT },
 633         /* numeric expressions */
 634         { "attribute['foo'] < 123",       -1,  MATCHER_LT },
 635         { "attribute['foo'] <= 123",      -1,  MATCHER_LE },
 636         { "attribute['foo'] = 123",       -1,  MATCHER_EQ },
 637         { "attribute['foo'] >= 123",      -1,  MATCHER_GE },
 638         { "attribute['foo'] > 123",       -1,  MATCHER_GT },
 639         /* datetime expressions */
 640         { "attribute['foo'] = "
 641           "2014-08-16",                   -1,  MATCHER_EQ },
 642         { "attribute['foo'] = "
 643           "17:23",                        -1,  MATCHER_EQ },
 644         { "attribute['foo'] = "
 645           "17:23:53",                     -1,  MATCHER_EQ },
 646         { "attribute['foo'] = "
 647           "17:23:53.123",                 -1,  MATCHER_EQ },
 648         { "attribute['foo'] = "
 649           "17:23:53.123456789",           -1,  MATCHER_EQ },
 650         { "attribute['foo'] = "
 651           "2014-08-16 17:23",             -1,  MATCHER_EQ },
 652         { "attribute['foo'] = "
 653           "2014-08-16 17:23:53",          -1,  MATCHER_EQ },
 654         /* NULL; while this is an implementation detail,
 655          * IS NULL currently maps to an equality matcher */
 656         { "attribute['foo'] IS NULL",     -1,  MATCHER_ISNULL },
 657         { "attribute['foo'] IS NOT NULL", -1,  MATCHER_ISNNULL },
 658         /* array expressions */
 659         { "backend < ['a']",              -1,  MATCHER_LT },
 660         { "backend <= ['a']",             -1,  MATCHER_LE },
 661         { "backend = ['a']",              -1,  MATCHER_EQ },
 662         { "backend != ['a']",             -1,  MATCHER_NE },
 663         { "backend >= ['a']",             -1,  MATCHER_GE },
 664         { "backend > ['a']",              -1,  MATCHER_GT },
 665         { "backend &^ ['a']",             -1,  -1 },
 666
 667         /* object field matchers */
 668         { "name < 'a'",                   -1,  MATCHER_LT },
 669         { "name <= 'a'",                  -1,  MATCHER_LE },
 670         { "name = 'a'",                   -1,  MATCHER_EQ },
 671         { "name != 'a'",                  -1,  MATCHER_NE },
 672         { "name >= 'a'",                  -1,  MATCHER_GE },
 673         { "name > 'a'",                   -1,  MATCHER_GT },
 674         { "last_update < 2014-10-01",     -1,  MATCHER_LT },
 675         { "last_update <= 2014-10-01",    -1,  MATCHER_LE },
 676         { "last_update = 2014-10-01",     -1,  MATCHER_EQ },
 677         { "last_update != 2014-10-01",    -1,  MATCHER_NE },
 678         { "last_update >= 2014-10-01",    -1,  MATCHER_GE },
 679         { "last_update > 2014-10-01",     -1,  MATCHER_GT },
 680         { "Last_Update >= 24D",           -1,  MATCHER_GE },
 681         { "age < 20s",                    -1,  MATCHER_LT },
 682         { "age <= 20s",                   -1,  MATCHER_LE },
 683         { "age = 20s",                    -1,  MATCHER_EQ },
 684         { "age != 20s",                   -1,  MATCHER_NE },
 685         { "age >= 20s",                   -1,  MATCHER_GE },
 686         { "age > 20s",                    -1,  MATCHER_GT },
 687         { "AGE <= 1m",                    -1,  MATCHER_LE },
 688         { "age > 1M",                     -1,  MATCHER_GT },
 689         { "age != 20Y",                   -1,  MATCHER_NE },
 690         { "age <= 2 * interval",          -1,  MATCHER_LE },
 691         { "interval < 20s",               -1,  MATCHER_LT },
 692         { "interval <= 20s",              -1,  MATCHER_LE },
 693         { "interval = 20s",               -1,  MATCHER_EQ },
 694         { "interval != 20s",              -1,  MATCHER_NE },
 695         { "interval >= 20s",              -1,  MATCHER_GE },
 696         { "interval > 20s",               -1,  MATCHER_GT },
 697         { "'be' IN backend",              -1,  MATCHER_IN },
 698         { "'be' NOT IN backend",          -1,  MATCHER_NIN },
 699         { "['a','b'] IN backend",         -1,  MATCHER_IN },
 700         { "['a','b'] NOT IN backend",     -1,  MATCHER_NIN },
 701
 702         /* check operator precedence */
 703         { "name = 'name' OR "
 704           "ANY service = 'name' AND "
 705           "ANY attribute = 'name' OR "
 706           "attribute['foo'] = 'bar'",     -1,  MATCHER_OR },
 707         { "name = 'name' AND "
 708           "ANY service = 'name' AND "
 709           "ANY attribute = 'name' OR "
 710           "attribute['foo'] = 'bar'",     -1,  MATCHER_OR },
 711         { "name = 'name' AND "
 712           "ANY service = 'name' OR "
 713           "ANY attribute = 'name' AND "
 714           "attribute['foo'] = 'bar'",     -1,  MATCHER_OR },
 715         { "(name = 'name' OR "
 716           "ANY service = 'name') AND "
 717           "(ANY attribute = 'name' OR "
 718           "attribute['foo'] = 'bar')",    -1,  MATCHER_AND },
 719         { "NOT name = 'name' OR "
 720           "ANY service = 'name'",         -1,  MATCHER_OR },
 721         { "NOT name = 'name' OR "
 722           "NOT ANY service = 'name'",     -1,  MATCHER_OR },
 723         { "NOT (name = 'name' OR "
 724           "NOT ANY service = 'name')",    -1,  MATCHER_NOT },
 725
 726         /* syntax errors */
 727         { "LIST",                         -1, -1 },
 728         { "foo &^ bar",                   -1, -1 },
 729         { "invalid",                      -1, -1 },
 730 };
 731
 732 START_TEST(test_parse_matcher)
 733 {
 734         sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
 735         sdb_store_matcher_t *m;
 736
 737         m = sdb_fe_parse_matcher(parse_matcher_data[_i].expr,
 738                         parse_matcher_data[_i].len, errbuf);
 739
 740         if (parse_matcher_data[_i].expected < 0) {
 741                 fail_unless(m == NULL,
 742                                 "sdb_fe_parse_matcher(%s) = %p; expected: NULL",
 743                                 parse_matcher_data[_i].expr, m);
 744                 sdb_object_deref(SDB_OBJ(m));
 745                 sdb_strbuf_destroy(errbuf);
 746                 return;
 747         }
 748
 749         fail_unless(m != NULL, "sdb_fe_parse_matcher(%s) = NULL; "
 750                         "expected: <matcher> (parser error: %s)",
 751                         parse_matcher_data[_i].expr, sdb_strbuf_string(errbuf));
 752         fail_unless(M(m)->type == parse_matcher_data[_i].expected,
 753                         "sdb_fe_parse_matcher(%s) returned matcher of type %d; "
 754                         "expected: %d", parse_matcher_data[_i].expr, M(m)->type,
 755                         parse_matcher_data[_i].expected);
 756
 757         sdb_object_deref(SDB_OBJ(m));
 758         sdb_strbuf_destroy(errbuf);
 759 }
 760 END_TEST
 761
 762 struct {
 763         const char *expr;
 764         int len;
 765         int expected;
 766 } parse_expr_data[] = {
 767         /* empty expressions */
 768         { NULL,                   -1, INT_MAX },
 769         { "",                     -1, INT_MAX },
 770
 771         /* constant expressions */
 772         { "'localhost'",          -1, 0 },
 773         { "123",                  -1, 0 },
 774         { "2014-08-16",           -1, 0 },
 775         { "17:23",                -1, 0 },
 776         { "17:23:53",             -1, 0 },
 777         { "17:23:53.123",         -1, 0 },
 778         { "17:23:53.123456789",   -1, 0 },
 779         { "2014-08-16 17:23",     -1, 0 },
 780         { "2014-08-16 17:23:53",  -1, 0 },
 781         { "10s",                  -1, 0 },
 782         { "60m",                  -1, 0 },
 783         { "10Y 24D 1h",           -1, 0 },
 784
 785         { "123 + 456",            -1, 0 },
 786         { "'foo' || 'bar'",       -1, 0 },
 787         { "456 - 123",            -1, 0 },
 788         { "1.2 * 3.4",            -1, 0 },
 789         { "1.2 / 3.4",            -1, 0 },
 790         { "5 % 2",                -1, 0 },
 791
 792         /* queryable fields */
 793         { "last_update",          -1, FIELD_VALUE },
 794         { "AGE",                  -1, FIELD_VALUE },
 795         { "interval",             -1, FIELD_VALUE },
 796         { "Last_Update",          -1, FIELD_VALUE },
 797         { "backend",              -1, FIELD_VALUE },
 798
 799         /* attributes */
 800         { "attribute['foo']",     -1, ATTR_VALUE },
 801
 802         /* arithmetic expressions */
 803         { "age + age",            -1, SDB_DATA_ADD },
 804         { "age - age",            -1, SDB_DATA_SUB },
 805         { "age * age",            -1, SDB_DATA_MUL },
 806         { "age / age",            -1, SDB_DATA_DIV },
 807         { "age % age",            -1, SDB_DATA_MOD },
 808         { "age || age",           -1, SDB_DATA_CONCAT },
 809
 810         /* operator precedence */
 811         { "age + age * age",      -1, SDB_DATA_ADD },
 812         { "age * age + age",      -1, SDB_DATA_ADD },
 813         { "age + age - age",      -1, SDB_DATA_SUB },
 814         { "age - age + age",      -1, SDB_DATA_ADD },
 815         { "(age + age) * age",    -1, SDB_DATA_MUL },
 816         { "age + (age * age)",    -1, SDB_DATA_ADD },
 817
 818         /* syntax errors */
 819         { "LIST",                 -1, INT_MAX },
 820         { "foo &^ bar",           -1, INT_MAX },
 821         { "invalid",              -1, INT_MAX },
 822 };
 823
 824 START_TEST(test_parse_expr)
 825 {
 826         sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
 827         sdb_store_expr_t *e;
 828
 829         e = sdb_fe_parse_expr(parse_expr_data[_i].expr,
 830                         parse_expr_data[_i].len, errbuf);
 831
 832         if (parse_expr_data[_i].expected == INT_MAX) {
 833                 fail_unless(e == NULL,
 834                                 "sdb_fe_parse_expr(%s) = %p; expected: NULL",
 835                                 parse_expr_data[_i].expr, e);
 836                 sdb_object_deref(SDB_OBJ(e));
 837                 sdb_strbuf_destroy(errbuf);
 838                 return;
 839         }
 840
 841         fail_unless(e != NULL, "sdb_fe_parse_expr(%s) = NULL; "
 842                         "expected: <expr> (parser error: %s)",
 843                         parse_expr_data[_i].expr, sdb_strbuf_string(errbuf));
 844         fail_unless(e->type == parse_expr_data[_i].expected,
 845                         "sdb_fe_parse_expr(%s) returned expression of type %d; "
 846                         "expected: %d", parse_expr_data[_i].expr, e->type,
 847                         parse_expr_data[_i].expected);
 848
 849         sdb_object_deref(SDB_OBJ(e));
 850         sdb_strbuf_destroy(errbuf);
 851 }
 852 END_TEST
 853
 854 TEST_MAIN("frontend::parser")
 855 {
 856         TCase *tc = tcase_create("core");
 857         TC_ADD_LOOP_TEST(tc, parse);
 858         TC_ADD_LOOP_TEST(tc, parse_matcher);
 859         TC_ADD_LOOP_TEST(tc, parse_expr);
 860         ADD_TCASE(tc);
 861 }
 862 TEST_MAIN_END
 863
 864 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 865