t/unit/parser/parser_test.c

   1 /*
   2  * SysDB - t/unit/parser/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 "parser/parser.h"
  33 #include "core/object.h"
  34 #include "core/store.h"
  35 #include "testutils.h"
  36
  37 #include <check.h>
  38 #include <limits.h>
  39
  40 /*
  41  * tests
  42  */
  43
  44 struct {
  45         const char *query;
  46         int len;
  47         int expected;
  48         int expected_type;
  49         int expected_extra; /* type-specific extra information */
  50 } parse_data[] = {
  51         /* empty commands */
  52         { NULL,                  -1, -1, 0, 0 },
  53         { "",                    -1,  0, 0, 0 },
  54         { ";",                   -1,  0, 0, 0 },
  55         { ";;",                  -1,  0, 0, 0 },
  56
  57         /* FETCH commands */
  58         { "FETCH host 'host'",   -1,  1, SDB_AST_TYPE_FETCH, SDB_HOST },
  59         { "FETCH host 'host' FILTER "
  60           "age > 60s",           -1,  1, SDB_AST_TYPE_FETCH, SDB_HOST },
  61         { "FETCH service "
  62           "'host'.'service'",    -1,  1, SDB_AST_TYPE_FETCH, SDB_SERVICE },
  63         { "FETCH metric "
  64           "'host'.'metric'",     -1,  1, SDB_AST_TYPE_FETCH, SDB_METRIC },
  65
  66         /* LIST commands */
  67         { "LIST hosts",            -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  68         { "LIST hosts -- foo",     -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  69         { "LIST hosts;",           -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  70         { "LIST hosts; INVALID",   11,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  71         { "LIST hosts FILTER "
  72           "age > 60s",             -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  73         { "LIST services",         -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
  74         { "LIST services FILTER "
  75           "age > 60s",             -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
  76         { "LIST metrics",          -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
  77         { "LIST metrics FILTER "
  78           "age > 60s",             -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
  79         /* field access */
  80         { "LIST hosts FILTER "
  81           "name = 'a'",            -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  82         { "LIST hosts FILTER "
  83           "last_update > 1s",      -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  84         { "LIST hosts FILTER "
  85           "age > 120s",            -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  86         { "LIST hosts FILTER "
  87           "interval > 10s",        -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  88         { "LIST hosts FILTER "
  89           "backend = ['b']",       -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  90         { "LIST hosts FILTER ANY "
  91           "attribute.value = 'a'", -1,  1, SDB_AST_TYPE_LIST, SDB_HOST },
  92         { "LIST services FILTER "
  93           "name = 'a'",            -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
  94         { "LIST services FILTER "
  95           "last_update > 1s",      -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
  96         { "LIST services FILTER "
  97           "age > 120s",            -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
  98         { "LIST services FILTER "
  99           "interval > 10s",        -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
 100         { "LIST services FILTER "
 101           "backend = ['b']",       -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
 102         { "LIST services FILTER ANY "
 103           "attribute.value = 'a'", -1,  1, SDB_AST_TYPE_LIST, SDB_SERVICE },
 104         { "LIST metrics FILTER "
 105           "name = 'a'",            -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
 106         { "LIST metrics FILTER "
 107           "last_update > 1s",      -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
 108         { "LIST metrics FILTER "
 109           "age > 120s",            -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
 110         { "LIST metrics FILTER "
 111           "interval > 10s",        -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
 112         { "LIST metrics FILTER "
 113           "backend = ['b']",       -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
 114         { "LIST metrics FILTER ANY "
 115           "attribute.value = 'a'", -1,  1, SDB_AST_TYPE_LIST, SDB_METRIC },
 116
 117         /* LOOKUP commands */
 118         { "LOOKUP hosts",        -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 119         { "LOOKUP hosts MATCHING "
 120           "name = 'host'",       -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 121         { "LOOKUP hosts MATCHING NOT "
 122           "name = 'host'",       -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 123         { "LOOKUP hosts MATCHING "
 124           "name =~ 'p' AND "
 125           "ANY service.name =~ 'p'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 126         { "LOOKUP hosts MATCHING NOT "
 127           "name =~ 'p' AND "
 128           "ANY service.name =~ 'p'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 129         { "LOOKUP hosts MATCHING "
 130           "name =~ 'p' AND "
 131           "ANY service.name =~ 'p' OR "
 132           "ANY service.name =~ 'r'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 133         { "LOOKUP hosts MATCHING NOT "
 134           "name =~ 'p' AND "
 135           "ANY service.name =~ 'p' OR "
 136           "ANY service.name =~ 'r'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 137         { "LOOKUP hosts MATCHING "
 138           "name =~ 'p' "
 139           "FILTER age > 1D",         -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 140         { "LOOKUP hosts MATCHING "
 141           "name =~ 'p' "
 142           "FILTER age > 1D AND "
 143           "interval < 240s" ,        -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 144         { "LOOKUP hosts MATCHING "
 145           "name =~ 'p' "
 146           "FILTER NOT age>1D",       -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 147         { "LOOKUP hosts MATCHING "
 148           "name =~ 'p' "
 149           "FILTER age>"
 150           "interval",                -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 151         { "LOOKUP hosts MATCHING "
 152           "host.name =~ 'p'",        -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 153         { "LOOKUP services",         -1,   1, SDB_AST_TYPE_LOOKUP, SDB_SERVICE },
 154         { "LOOKUP services MATCHING ANY "
 155           "attribute.name =~ 'a'",   -1,   1, SDB_AST_TYPE_LOOKUP, SDB_SERVICE },
 156         { "LOOKUP services MATCHING "
 157           "host.name = 'p'",         -1,   1, SDB_AST_TYPE_LOOKUP, SDB_SERVICE },
 158         { "LOOKUP services MATCHING "
 159           "service.name = 'p'",      -1,   1, SDB_AST_TYPE_LOOKUP, SDB_SERVICE },
 160         { "LOOKUP metrics",          -1,   1, SDB_AST_TYPE_LOOKUP, SDB_METRIC },
 161         { "LOOKUP metrics MATCHING ANY "
 162           "attribute.name =~ 'a'",   -1,   1, SDB_AST_TYPE_LOOKUP, SDB_METRIC },
 163         { "LOOKUP metrics MATCHING "
 164           "host.name = 'p'",         -1,   1, SDB_AST_TYPE_LOOKUP, SDB_METRIC },
 165         { "LOOKUP metrics MATCHING "
 166           "metric.name = 'p'",       -1,   1, SDB_AST_TYPE_LOOKUP, SDB_METRIC },
 167
 168         /* TIMESERIES commands */
 169         { "TIMESERIES 'host'.'metric' "
 170           "START 2014-01-01 "
 171           "END 2014-12-31 "
 172           "23:59:59",            -1,  1, SDB_AST_TYPE_TIMESERIES, 0 },
 173         { "TIMESERIES 'host'.'metric' "
 174           "START 2014-02-02 "
 175           "14:02",               -1,  1, SDB_AST_TYPE_TIMESERIES, 0 },
 176         /* the end time has to be greater than the start time;
 177          * we'll be safe for about 200 years ;-) */
 178         { "TIMESERIES 'host'.'metric' "
 179           "END 2214-02-02",      -1,  1, SDB_AST_TYPE_TIMESERIES, 0 },
 180         { "TIMESERIES "
 181           "'host'.'metric'",     -1,  1, SDB_AST_TYPE_TIMESERIES, 0 },
 182
 183         /* STORE commands */
 184         { "STORE host 'host'",   -1,  1, SDB_AST_TYPE_STORE, SDB_HOST },
 185         { "STORE host 'host' "
 186           "LAST UPDATE "
 187           "2015-02-01",          -1,  1, SDB_AST_TYPE_STORE, SDB_HOST },
 188         { "STORE host attribute "
 189           "'host'.'key' 123",    -1,  1, SDB_AST_TYPE_STORE, SDB_ATTRIBUTE },
 190         { "STORE host attribute "
 191           "'host'.'key' 123 "
 192           "LAST UPDATE "
 193           "2015-02-01",          -1,  1, SDB_AST_TYPE_STORE, SDB_ATTRIBUTE },
 194         { "STORE service "
 195           "'host'.'svc'",        -1,  1, SDB_AST_TYPE_STORE, SDB_SERVICE },
 196         { "STORE service "
 197           "'host'.'svc' "
 198           "LAST UPDATE "
 199           "2015-02-01",          -1,  1, SDB_AST_TYPE_STORE, SDB_SERVICE },
 200         { "STORE service attribute "
 201           "'host'.'svc'.'key' "
 202           "123",                 -1,  1, SDB_AST_TYPE_STORE, SDB_ATTRIBUTE },
 203         { "STORE service attribute "
 204           "'host'.'svc'.'key' "
 205           "123 "
 206           "LAST UPDATE "
 207           "2015-02-01",          -1,  1, SDB_AST_TYPE_STORE, SDB_ATTRIBUTE },
 208         { "STORE metric "
 209           "'host'.'metric'",     -1,  1, SDB_AST_TYPE_STORE, SDB_METRIC },
 210         { "STORE metric "
 211           "'host'.'metric' "
 212           "LAST UPDATE "
 213           "2015-02-01",          -1,  1, SDB_AST_TYPE_STORE, SDB_METRIC },
 214         { "STORE metric "
 215           "'host'.'metric' "
 216           "STORE 'typ' 'id' "
 217           "LAST UPDATE "
 218           "2015-02-01",          -1,  1, SDB_AST_TYPE_STORE, SDB_METRIC },
 219         { "STORE metric attribute "
 220           "'host'.'metric'.'key' "
 221           "123",                 -1,  1, SDB_AST_TYPE_STORE, SDB_ATTRIBUTE },
 222         { "STORE metric attribute "
 223           "'host'.'metric'.'key' "
 224           "123 "
 225           "LAST UPDATE "
 226           "2015-02-01",          -1,  1, SDB_AST_TYPE_STORE, SDB_ATTRIBUTE },
 227
 228         /* string constants */
 229         { "LOOKUP hosts MATCHING "
 230           "name = ''''",         -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 231         { "LOOKUP hosts MATCHING "
 232           "name = '''foo'",      -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 233         { "LOOKUP hosts MATCHING "
 234           "name = 'f''oo'",      -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 235         { "LOOKUP hosts MATCHING "
 236           "name = 'foo'''",      -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 237         { "LOOKUP hosts MATCHING "
 238           "name = '''",          -1, -1, 0, SDB_HOST },
 239
 240         /* numeric constants */
 241         { "LOOKUP hosts MATCHING "
 242           "attribute['foo'] = "
 243           "1234",                -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 244         { "LOOKUP hosts MATCHING "
 245           "attribute['foo'] != "
 246           "+234",                -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 247         { "LOOKUP hosts MATCHING "
 248           "attribute['foo'] < "
 249           "-234",                -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 250         { "LOOKUP hosts MATCHING "
 251           "attribute['foo'] > "
 252           "12.4",                -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 253         { "LOOKUP hosts MATCHING "
 254           "attribute['foo'] <= "
 255           "12. + .3",            -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 256         { "LOOKUP hosts MATCHING "
 257           "attribute['foo'] <= "
 258           "'f' || 'oo'",         -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 259         { "LOOKUP hosts MATCHING "
 260           "attribute['foo'] >= "
 261           ".4",                  -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 262         { "LOOKUP hosts MATCHING "
 263           "attribute['foo'] = "
 264           "+12e3",               -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 265         { "LOOKUP hosts MATCHING "
 266           "attribute['foo'] = "
 267           "+12e-3",              -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 268         { "LOOKUP hosts MATCHING "
 269           "attribute['foo'] = "
 270           "-12e+3",              -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 271
 272         /* date, time, interval constants */
 273         { "LOOKUP hosts MATCHING "
 274           "attribute['foo'] = "
 275           "1 Y 42D",             -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 276         { "LOOKUP hosts MATCHING "
 277           "attribute['foo'] = "
 278           "1s 42D",              -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 279         /*
 280          * TODO: Something like 1Y42D should work as well but it doesn't since
 281          * the scanner will tokenize it into {digit}{identifier} :-/
 282          *
 283         { "LOOKUP hosts MATCHING "
 284           "attribute['foo'] = "
 285           "1Y42D",               -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 286          */
 287
 288         /* array constants */
 289         { "LOOKUP hosts MATCHING "
 290           "backend = ['foo']",   -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 291         { "LOOKUP hosts MATCHING "
 292           "backend = ['a','b']", -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 293
 294         /* array iteration */
 295         { "LOOKUP hosts MATCHING "
 296           "'foo' IN backend",   -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 297         { "LOOKUP hosts MATCHING 'foo' "
 298           "NOT IN backend",     -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 299         { "LOOKUP hosts MATCHING "
 300           "['foo','bar'] "
 301           "IN backend ",        -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 302         /* attribute type is unknown */
 303         { "LOOKUP hosts MATCHING "
 304           "attribute['backend'] "
 305           "IN backend ",        -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 306         { "LOOKUP hosts MATCHING "
 307           "ANY backend < 'b'",  -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 308         { "LOOKUP hosts MATCHING "
 309           "ANY backend <= 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 310         { "LOOKUP hosts MATCHING "
 311           "ANY backend = 'b'",  -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 312         { "LOOKUP hosts MATCHING "
 313           "ANY backend != 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 314         { "LOOKUP hosts MATCHING "
 315           "ANY backend >= 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 316         { "LOOKUP hosts MATCHING "
 317           "ANY backend > 'b'",  -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 318         { "LOOKUP hosts MATCHING "
 319           "ANY backend =~ 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 320         { "LOOKUP hosts MATCHING "
 321           "ANY backend !~ 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 322         { "LOOKUP hosts MATCHING "
 323           "ALL backend < 'b'",  -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 324         { "LOOKUP hosts MATCHING "
 325           "ALL backend <= 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 326         { "LOOKUP hosts MATCHING "
 327           "ALL backend = 'b'",  -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 328         { "LOOKUP hosts MATCHING "
 329           "ALL backend != 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 330         { "LOOKUP hosts MATCHING "
 331           "ALL backend >= 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 332         { "LOOKUP hosts MATCHING "
 333           "ALL backend > 'b'",  -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 334         { "LOOKUP hosts MATCHING "
 335           "ALL backend =~ 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 336         { "LOOKUP hosts MATCHING "
 337           "ALL backend !~ 'b'", -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 338         /* attribute type is unknown */
 339         { "LOOKUP hosts MATCHING "
 340           "ANY backend = attribute['backend']",
 341                                 -1,   1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 342
 343         /* valid operand types */
 344         { "LOOKUP hosts MATCHING "
 345           "age * 1 > 0s",        -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 346         { "LOOKUP hosts MATCHING "
 347           "age / 1 > 0s",        -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 348         { "LOOKUP hosts MATCHING "
 349           "name > ''",           -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 350         { "LOOKUP hosts MATCHING "
 351           "name >= ''",          -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 352         { "LOOKUP hosts MATCHING "
 353           "name != ''",          -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 354         { "LOOKUP hosts MATCHING "
 355           "name = ''",           -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 356         { "LOOKUP hosts MATCHING "
 357           "name <= ''",          -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 358         { "LOOKUP hosts MATCHING "
 359           "name < ''",           -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 360
 361         /* typed expressions */
 362         { "LOOKUP services MATCHING "
 363           "host.attribute['a'] = 'a'",
 364                                  -1,  1, SDB_AST_TYPE_LOOKUP, SDB_SERVICE },
 365         /* TODO: this should work but the analyzer currently sees ATTRIBUTE
 366          * (instead of SERVICE-ATTRIBUTE) as the child type
 367         { "LOOKUP services MATCHING "
 368           "ANY attribute.service.name = 's'",
 369                                  -1,  1, SDB_AST_TYPE_LOOKUP, SDB_SERVICE },
 370          */
 371         { "LOOKUP hosts MATCHING "
 372           "ANY service.service.name = 's'",
 373                                  -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 374
 375         /* NULL */
 376         { "LOOKUP hosts MATCHING "
 377           "attribute['foo'] "
 378           "IS NULL",             -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 379         { "LOOKUP hosts MATCHING "
 380           "attribute['foo'] "
 381           "IS NOT NULL",         -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 382         { "LOOKUP hosts MATCHING "
 383           "NOT attribute['foo'] "
 384           "IS NULL",             -1,  1, SDB_AST_TYPE_LOOKUP, SDB_HOST },
 385         { "LOOKUP hosts MATCHING "
 386           "ANY service.name IS NULL", -1, -1, 0, 0 },
 387
 388         /* invalid numeric constants */
 389         { "LOOKUP hosts MATCHING "
 390           "attribute['foo'] = "
 391           "+-12e+3",             -1, -1, 0, 0 },
 392         { "LOOKUP hosts MATCHING "
 393           "attribute['foo'] = "
 394           "-12e-+3",             -1, -1, 0, 0 },
 395         { "LOOKUP hosts MATCHING "
 396           "attribute['foo'] = "
 397           "e+3",                 -1, -1, 0, 0 },
 398         { "LOOKUP hosts MATCHING "
 399           "attribute['foo'] = "
 400           "3e",                  -1, -1, 0, 0 },
 401         /* following SQL standard, we don't support hex numbers */
 402         { "LOOKUP hosts MATCHING "
 403           "attribute['foo'] = "
 404           "0x12",                -1, -1, 0, 0 },
 405
 406         /* invalid expressions */
 407         { "LOOKUP hosts MATCHING "
 408           "attr['foo'] = 1.23",  -1, -1, 0, 0 },
 409         { "LOOKUP hosts MATCHING "
 410           "attr['foo'] IS NULL", -1, -1, 0, 0 },
 411
 412         /* comments */
 413         { "/* some comment */",  -1,  0, 0, 0 },
 414         { "-- another comment",  -1,  0, 0, 0 },
 415
 416         /* syntax errors */
 417         { "INVALID",             -1, -1, 0, 0 },
 418         { "FETCH host",          -1, -1, 0, 0 },
 419         { "FETCH 'host'",        -1, -1, 0, 0 },
 420         { "LIST hosts; INVALID", -1, -1, 0, 0 },
 421         { "/* some incomplete",  -1, -1, 0, 0 },
 422
 423         /*
 424          * syntactically correct but semantically invalid commands
 425          */
 426
 427         /* invalid fields */
 428         { "LIST hosts FILTER "
 429           "field = 'a'",           -1, -1, 0, 0 },
 430         { "LIST services FILTER "
 431           "field = 'a'",           -1, -1, 0, 0 },
 432         { "LIST metrics FILTER "
 433           "field = 'a'",           -1, -1, 0, 0 },
 434         { "LIST hosts FILTER "
 435           "value = 'a'",           -1, -1, 0, 0 },
 436         { "LIST services FILTER "
 437           "value = 'a'",           -1, -1, 0, 0 },
 438         { "LIST metrics FILTER "
 439           "value = 'a'",           -1, -1, 0, 0 },
 440         { "LIST metrics FILTER "
 441           "name.1 = 'a'",          -1, -1, 0, 0 },
 442
 443         /* type mismatches */
 444         { "LOOKUP hosts MATCHING "
 445           "attribute['foo'] = "
 446           "1.23 + 'foo'",       -1,  -1, 0, 0 },
 447         { "LOOKUP hosts MATCHING "
 448           "1 IN backend ",      -1,  -1, 0, 0 },
 449         { "LOOKUP hosts MATCHING "
 450           "1 NOT IN backend ",  -1,  -1, 0, 0 },
 451         { "LOOKUP hosts MATCHING "
 452           "age > 0",             -1, -1, 0, 0 },
 453         { "LOOKUP hosts MATCHING "
 454           "NOT age > 0",         -1, -1, 0, 0 },
 455         { "LOOKUP hosts MATCHING "
 456           "age >= 0",            -1, -1, 0, 0 },
 457         { "LOOKUP hosts MATCHING "
 458           "age = 0",             -1, -1, 0, 0 },
 459         { "LOOKUP hosts MATCHING "
 460           "age != 0",            -1, -1, 0, 0 },
 461         { "LOOKUP hosts MATCHING "
 462           "age <= 0",            -1, -1, 0, 0 },
 463         { "LOOKUP hosts MATCHING "
 464           "age < 0",             -1, -1, 0, 0 },
 465         { "LOOKUP hosts MATCHING "
 466           "age + 1 > 0s",        -1, -1, 0, 0 },
 467         { "LOOKUP hosts MATCHING "
 468           "age - 1 > 0s",        -1, -1, 0, 0 },
 469
 470         /* datetime <mul/div> integer is allowed */
 471         { "LOOKUP hosts MATCHING "
 472           "age || 1 > 0s",       -1, -1, 0, 0 },
 473         { "LOOKUP hosts MATCHING "
 474           "name + 1 = ''",       -1, -1, 0, 0 },
 475         { "LOOKUP hosts MATCHING "
 476           "name - 1 = ''",       -1, -1, 0, 0 },
 477         { "LOOKUP hosts MATCHING "
 478           "name * 1 = ''",       -1, -1, 0, 0 },
 479         { "LOOKUP hosts MATCHING "
 480           "name / 1 = ''",       -1, -1, 0, 0 },
 481         { "LOOKUP hosts MATCHING "
 482           "name % 1 = ''",       -1, -1, 0, 0 },
 483         { "LOOKUP hosts MATCHING "
 484           "(name % 1) + 1 = ''", -1, -1, 0, 0 },
 485         { "LOOKUP hosts MATCHING "
 486           "1 + (name % 1) = ''", -1, -1, 0, 0 },
 487         { "LOOKUP hosts MATCHING "
 488           "'' = 1 + (name % 1)", -1, -1, 0, 0 },
 489         { "LOOKUP hosts MATCHING "
 490           "age > 0 AND "
 491           "age = 0s",            -1, -1, 0, 0 },
 492         { "LOOKUP hosts MATCHING "
 493           "age = 0s AND "
 494           "age > 0",             -1, -1, 0, 0 },
 495         { "LOOKUP services MATCHING "
 496           "host.name > 0",       -1, -1, 0, 0 },
 497         { "LOOKUP services MATCHING "
 498           "backend > 'b'",       -1, -1, 0, 0 },
 499         { "LOOKUP services MATCHING "
 500           "'b' > backend",       -1, -1, 0, 0 },
 501         { "LOOKUP services MATCHING "
 502           "attribute['a'] > backend",
 503                                  -1, -1, 0, 0 },
 504         { "LOOKUP services MATCHING "
 505           "backend > attribute['a']",
 506                                  -1, -1, 0, 0 },
 507         { "LOOKUP services MATCHING "
 508           "host.name + 1 = ''",  -1, -1, 0, 0 },
 509         { "LOOKUP hosts MATCHING "
 510           "'a' + 1 IN 'b'",      -1, -1, 0, 0 },
 511         { "LOOKUP hosts MATCHING "
 512           "'a' IN 'b' - 1",      -1, -1, 0, 0 },
 513         { "LOOKUP hosts MATCHING "
 514           "name + 1 IN 'b'",     -1, -1, 0, 0 },
 515         { "LOOKUP hosts MATCHING "
 516           "'a' IN name - 1",     -1, -1, 0, 0 },
 517         { "LOOKUP hosts MATCHING "
 518           "'b' IN 'abc'",        -1, -1, 0, 0 },
 519         { "LOOKUP hosts MATCHING "
 520           "1 IN age",            -1, -1, 0, 0 },
 521         { "LOOKUP hosts MATCHING "
 522           "name =~ 'a' + 1",     -1, -1, 0, 0 },
 523         { "LOOKUP hosts MATCHING "
 524           "name =~ name + 1",    -1, -1, 0, 0 },
 525         { "LOOKUP hosts MATCHING "
 526           "name + 1 =~ 'a'",     -1, -1, 0, 0 },
 527         { "LOOKUP hosts MATCHING "
 528           "name =~ 1",           -1, -1, 0, 0 },
 529         { "LOOKUP hosts MATCHING "
 530           "name + 1 IS NULL",    -1, -1, 0, 0 },
 531         { "LOOKUP hosts FILTER "
 532           "name + 1 IS NULL",    -1, -1, 0, 0 },
 533
 534         /* invalid iterators */
 535         { "LOOKUP hosts MATCHING "
 536           "ANY backend !~ backend",
 537                                 -1,  -1, 0, 0 },
 538         { "LOOKUP hosts MATCHING "
 539           "ANY backend = 1",    -1,  -1, 0, 0 },
 540         { "LOOKUP hosts MATCHING "
 541           "ANY 'patt' =~ 'p'",  -1,  -1, 0, 0 },
 542         { "LOOKUP hosts MATCHING "
 543           "ALL 1 || '2' < '3'", -1,  -1, 0, 0 },
 544         { "LOOKUP hosts MATCHING "
 545           "ALL name =~ 'a'",    -1,  -1, 0, 0 },
 546         /* this could work in theory but is not supported atm */
 547         { "LOOKUP hosts MATCHING "
 548           "ANY backend || 'a' = 'b'",
 549                                 -1,  -1, 0, 0 },
 550
 551         /* invalid LIST commands */
 552         { "LIST",                -1, -1, 0, 0 },
 553         { "LIST foo",            -1, -1, 0, 0 },
 554         { "LIST hosts MATCHING "
 555           "name = 'host'",       -1, -1, 0, 0 },
 556         { "LIST foo FILTER "
 557           "age > 60s",           -1, -1, 0, 0 },
 558
 559         /* invalid FETCH commands */
 560         { "FETCH host 'host' MATCHING "
 561           "name = 'host'",       -1, -1, 0, 0 },
 562         { "FETCH service 'host'",-1, -1, 0, 0 },
 563         { "FETCH metric 'host'", -1, -1, 0, 0 },
 564         { "FETCH host "
 565           "'host'.'localhost'",  -1, -1, 0, 0 },
 566         { "FETCH foo 'host'",    -1, -1, 0, 0 },
 567         { "FETCH foo 'host' FILTER "
 568           "age > 60s",           -1, -1, 0, 0 },
 569
 570         /* invalid LOOKUP commands */
 571         { "LOOKUP foo",          -1, -1, 0, 0 },
 572         { "LOOKUP foo MATCHING "
 573           "name = 'host'",       -1, -1, 0, 0 },
 574         { "LOOKUP foo FILTER "
 575           "age > 60s",           -1, -1, 0, 0 },
 576         { "LOOKUP foo MATCHING "
 577           "name = 'host' FILTER "
 578           "age > 60s",           -1, -1, 0, 0 },
 579         { "LOOKUP hosts MATCHING "
 580           "attribute['foo'] <= "
 581           "f || 'oo'",           -1, -1, 0, 0 },
 582         { "LOOKUP hosts MATCHING "
 583           "attribute['foo'] <= "
 584           "'f' || oo",           -1, -1, 0, 0 },
 585         { "LOOKUP hosts MATCHING "
 586           "ANY host.name = 'host'",   -1, -1, 0, 0 },
 587         { "LOOKUP hosts MATCHING "
 588           "ANY service.name > 1",     -1, -1, 0, 0 },
 589         { "LOOKUP hosts MATCHING "
 590           "service.name = 's'",       -1, -1, 0, 0 },
 591         { "LOOKUP services MATCHING "
 592           "ANY host.name = 'host'",   -1, -1, 0, 0 },
 593         { "LOOKUP services MATCHING "
 594           "ANY service.name = 'svc'", -1, -1, 0, 0 },
 595         { "LOOKUP services MATCHING "
 596           "ANY metric.name = 'm'",    -1, -1, 0, 0 },
 597         { "LOOKUP services MATCHING "
 598           "metric.name = 'm'",        -1, -1, 0, 0 },
 599         { "LOOKUP metrics MATCHING "
 600           "ANY host.name = 'host'",   -1, -1, 0, 0 },
 601         { "LOOKUP metrics MATCHING "
 602           "ANY service.name = 'svc'", -1, -1, 0, 0 },
 603         { "LOOKUP metrics MATCHING "
 604           "ANY metric.name = 'm'",    -1, -1, 0, 0 },
 605         { "LOOKUP metrics MATCHING "
 606           "service.name = 'm'",       -1, -1, 0, 0 },
 607
 608         /* invalid STORE commands */
 609         { "STORE host "
 610           "'obj'.'host'",        -1, -1, 0, 0 },
 611         { "STORE host attribute "
 612           ".'key' 123",          -1, -1, 0, 0 },
 613         { "STORE host attribute "
 614           "'o'.'h'.'key' 123",   -1, -1, 0, 0 },
 615         { "STORE service 'svc'", -1, -1, 0, 0 },
 616         { "STORE service "
 617           "'host'.'svc' "
 618           "STORE 'typ' 'id' "
 619           "LAST UPDATE "
 620           "2015-02-01",          -1, -1, 0, 0 },
 621         { "STORE service attribute "
 622           "'svc'.'key' 123",     -1, -1, 0, 0 },
 623         { "STORE metric 'm'",    -1, -1, 0, 0 },
 624         { "STORE metric "
 625           "'host'.'metric' "
 626           "STORE 'typ'.'id' "
 627           "LAST UPDATE "
 628           "2015-02-01",          -1, -1, 0, 0 },
 629         { "STORE metric attribute "
 630           "'metric'.'key' 123",  -1, -1, 0, 0 },
 631 };
 632
 633 START_TEST(test_parse)
 634 {
 635         sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
 636         sdb_llist_t *check;
 637         sdb_ast_node_t *node;
 638         sdb_store_matcher_t *m;
 639         _Bool ok;
 640
 641         check = sdb_parser_parse(parse_data[_i].query,
 642                         parse_data[_i].len, errbuf);
 643         if (parse_data[_i].expected < 0)
 644                 ok = check == 0;
 645         else
 646                 ok = sdb_llist_len(check) == (size_t)parse_data[_i].expected;
 647
 648         fail_unless(ok, "sdb_parser_parse(%s) = %p (len: %zu); expected: %d "
 649                         "(parse error: %s)", parse_data[_i].query, check,
 650                         sdb_llist_len(check), parse_data[_i].expected,
 651                         sdb_strbuf_string(errbuf));
 652
 653         if (! check) {
 654                 sdb_strbuf_destroy(errbuf);
 655                 return;
 656         }
 657
 658         if ((! parse_data[_i].expected_type)
 659                         || (parse_data[_i].expected <= 0)) {
 660                 sdb_llist_destroy(check);
 661                 sdb_strbuf_destroy(errbuf);
 662                 return;
 663         }
 664
 665         node = SDB_AST_NODE(sdb_llist_get(check, 0));
 666         fail_unless(node->type == parse_data[_i].expected_type,
 667                         "sdb_parser_parse(%s)->type = %i; expected: %d",
 668                         parse_data[_i].query, node->type,
 669                         parse_data[_i].expected_type);
 670
 671         if (node->type == SDB_AST_TYPE_FETCH) {
 672                 sdb_ast_fetch_t *f = SDB_AST_FETCH(node);
 673                 fail_unless(f->obj_type == parse_data[_i].expected_extra,
 674                                 "sdb_parser_parse(%s)->obj_type = %s; expected: %s",
 675                                 parse_data[_i].query, SDB_STORE_TYPE_TO_NAME(f->obj_type),
 676                                 SDB_STORE_TYPE_TO_NAME(parse_data[_i].expected_extra));
 677         }
 678         else if (node->type == SDB_AST_TYPE_LIST) {
 679                 sdb_ast_list_t *l = SDB_AST_LIST(node);
 680                 fail_unless(l->obj_type == parse_data[_i].expected_extra,
 681                                 "sdb_parser_parse(%s)->obj_type = %s; expected: %s",
 682                                 parse_data[_i].query, SDB_STORE_TYPE_TO_NAME(l->obj_type),
 683                                 SDB_STORE_TYPE_TO_NAME(parse_data[_i].expected_extra));
 684         }
 685         else if (node->type == SDB_AST_TYPE_LOOKUP) {
 686                 sdb_ast_lookup_t *l = SDB_AST_LOOKUP(node);
 687                 fail_unless(l->obj_type == parse_data[_i].expected_extra,
 688                                 "sdb_parser_parse(%s)->obj_type = %s; expected: %s",
 689                                 parse_data[_i].query, SDB_STORE_TYPE_TO_NAME(l->obj_type),
 690                                 SDB_STORE_TYPE_TO_NAME(parse_data[_i].expected_extra));
 691         }
 692         else if (node->type == SDB_AST_TYPE_STORE) {
 693                 sdb_ast_store_t *s = SDB_AST_STORE(node);
 694                 fail_unless(s->obj_type == parse_data[_i].expected_extra,
 695                                 "sdb_parser_parse(%s)->obj_type = %s; expected: %s",
 696                                 parse_data[_i].query, SDB_STORE_TYPE_TO_NAME(s->obj_type),
 697                                 SDB_STORE_TYPE_TO_NAME(parse_data[_i].expected_extra));
 698         }
 699
 700         /* TODO: this should move into front-end specific tests */
 701         m = sdb_store_query_prepare(node);
 702         fail_unless(m != NULL,
 703                         "sdb_store_query_prepare(AST<%s>) = NULL; expected: <m>",
 704                         parse_data[_i].query);
 705
 706         sdb_object_deref(SDB_OBJ(node));
 707         sdb_object_deref(SDB_OBJ(m));
 708         sdb_llist_destroy(check);
 709         sdb_strbuf_destroy(errbuf);
 710 }
 711 END_TEST
 712
 713 struct {
 714         const char *expr;
 715         int len;
 716         int expected;
 717 } parse_conditional_data[] = {
 718         /* empty expressions */
 719         { NULL,                           -1, -1 },
 720         { "",                             -1, -1 },
 721
 722         /* match hosts by name */
 723         { "name < 'localhost'",           -1,  SDB_AST_LT },
 724         { "name <= 'localhost'",          -1,  SDB_AST_LE },
 725         { "name = 'localhost'",           -1,  SDB_AST_EQ },
 726         { "name != 'localhost'",          -1,  SDB_AST_NE },
 727         { "name >= 'localhost'",          -1,  SDB_AST_GE },
 728         { "name > 'localhost'",           -1,  SDB_AST_GT },
 729         { "name =~ 'host'",               -1,  SDB_AST_REGEX },
 730         { "name !~ 'host'",               -1,  SDB_AST_NREGEX },
 731         { "name = 'localhost' -- foo",    -1,  SDB_AST_EQ },
 732         { "name = 'host' <garbage>",      13,  SDB_AST_EQ },
 733         { "name &^ 'localhost'",          -1,  -1 },
 734         /* match by backend */
 735         { "ANY backend < 'be'",           -1,  SDB_AST_ANY },
 736         { "ANY backend <= 'be'",          -1,  SDB_AST_ANY },
 737         { "ANY backend = 'be'",           -1,  SDB_AST_ANY },
 738         { "ANY backend != 'be'",          -1,  SDB_AST_ANY },
 739         { "ANY backend >= 'be'",          -1,  SDB_AST_ANY },
 740         { "ANY backend > 'be'",           -1,  SDB_AST_ANY },
 741         { "ALL backend < 'be'",           -1,  SDB_AST_ALL },
 742         { "ALL backend <= 'be'",          -1,  SDB_AST_ALL },
 743         { "ALL backend = 'be'",           -1,  SDB_AST_ALL },
 744         { "ALL backend != 'be'",          -1,  SDB_AST_ALL },
 745         { "ALL backend >= 'be'",          -1,  SDB_AST_ALL },
 746         { "ALL backend > 'be'",           -1,  SDB_AST_ALL },
 747         { "ANY backend &^ 'be'",          -1,  -1 },
 748         /* match hosts by service */
 749         { "ANY service.name < 'name'",         -1,  SDB_AST_ANY },
 750         { "ANY service.name <= 'name'",        -1,  SDB_AST_ANY },
 751         { "ANY service.name = 'name'",         -1,  SDB_AST_ANY },
 752         { "ANY service.name != 'name'",        -1,  SDB_AST_ANY },
 753         { "ANY service.name >= 'name'",        -1,  SDB_AST_ANY },
 754         { "ANY service.name > 'name'",         -1,  SDB_AST_ANY },
 755         { "ANY service.name =~ 'pattern'",     -1,  SDB_AST_ANY },
 756         { "ANY service.name !~ 'pattern'",     -1,  SDB_AST_ANY },
 757         { "ANY service.name &^ 'name'",        -1,  -1 },
 758         { "ALL service.name < 'name'",         -1,  SDB_AST_ALL },
 759         { "ALL service.name <= 'name'",        -1,  SDB_AST_ALL },
 760         { "ALL service.name = 'name'",         -1,  SDB_AST_ALL },
 761         { "ALL service.name != 'name'",        -1,  SDB_AST_ALL },
 762         { "ALL service.name >= 'name'",        -1,  SDB_AST_ALL },
 763         { "ALL service.name > 'name'",         -1,  SDB_AST_ALL },
 764         { "ALL service.name =~ 'pattern'",     -1,  SDB_AST_ALL },
 765         { "ALL service.name !~ 'pattern'",     -1,  SDB_AST_ALL },
 766         { "ALL service.name &^ 'name'",        -1,  -1 },
 767         { "ANY service < 'name'",              -1,  -1 },
 768         /* match hosts by metric */
 769         { "ANY metric.name < 'name'",          -1,  SDB_AST_ANY },
 770         { "ANY metric.name <= 'name'",         -1,  SDB_AST_ANY },
 771         { "ANY metric.name = 'name'",          -1,  SDB_AST_ANY },
 772         { "ANY metric.name != 'name'",         -1,  SDB_AST_ANY },
 773         { "ANY metric.name >= 'name'",         -1,  SDB_AST_ANY },
 774         { "ANY metric.name > 'name'",          -1,  SDB_AST_ANY },
 775         { "ANY metric.name =~ 'pattern'",      -1,  SDB_AST_ANY },
 776         { "ANY metric.name !~ 'pattern'",      -1,  SDB_AST_ANY },
 777         { "ANY metric.name &^ 'pattern'",      -1,  -1 },
 778         { "ALL metric.name < 'name'",          -1,  SDB_AST_ALL },
 779         { "ALL metric.name <= 'name'",         -1,  SDB_AST_ALL },
 780         { "ALL metric.name = 'name'",          -1,  SDB_AST_ALL },
 781         { "ALL metric.name != 'name'",         -1,  SDB_AST_ALL },
 782         { "ALL metric.name >= 'name'",         -1,  SDB_AST_ALL },
 783         { "ALL metric.name > 'name'",          -1,  SDB_AST_ALL },
 784         { "ALL metric.name =~ 'pattern'",      -1,  SDB_AST_ALL },
 785         { "ALL metric.name !~ 'pattern'",      -1,  SDB_AST_ALL },
 786         { "ALL metric.name &^ 'pattern'",      -1,  -1 },
 787         { "ANY metric <= 'name'",              -1,  -1 },
 788         /* match hosts by attribute */
 789         { "ANY attribute.name < 'name'",       -1,  SDB_AST_ANY },
 790         { "ANY attribute.name <= 'name'",      -1,  SDB_AST_ANY },
 791         { "ANY attribute.name = 'name'",       -1,  SDB_AST_ANY },
 792         { "ANY attribute.name != 'name'",      -1,  SDB_AST_ANY },
 793         { "ANY attribute.name >= 'name'",      -1,  SDB_AST_ANY },
 794         { "ANY attribute.name > 'name'",       -1,  SDB_AST_ANY },
 795         { "ANY attribute.name =~ 'pattern'",   -1,  SDB_AST_ANY },
 796         { "ANY attribute.name !~ 'pattern'",   -1,  SDB_AST_ANY },
 797         { "ANY attribute.name &^ 'pattern'",   -1,  -1 },
 798         { "ALL attribute.name < 'name'",       -1,  SDB_AST_ALL },
 799         { "ALL attribute.name <= 'name'",      -1,  SDB_AST_ALL },
 800         { "ALL attribute.name = 'name'",       -1,  SDB_AST_ALL },
 801         { "ALL attribute.name != 'name'",      -1,  SDB_AST_ALL },
 802         { "ALL attribute.name >= 'name'",      -1,  SDB_AST_ALL },
 803         { "ALL attribute.name > 'name'",       -1,  SDB_AST_ALL },
 804         { "ALL attribute.name =~ 'pattern'",   -1,  SDB_AST_ALL },
 805         { "ALL attribute.name !~ 'pattern'",   -1,  SDB_AST_ALL },
 806         { "ALL attribute.name &^ 'pattern'",   -1,  -1 },
 807         { "ANY attribute !~ 'pattern'",        -1,  -1 },
 808         /* composite expressions */
 809         { "name =~ 'pattern' AND "
 810           "ANY service.name =~ 'pattern'",     -1,  SDB_AST_AND },
 811         { "name =~ 'pattern' OR "
 812           "ANY service.name =~ 'pattern'",     -1,  SDB_AST_OR },
 813         { "NOT name = 'host'",                 -1,  SDB_AST_NOT },
 814         /* numeric expressions */
 815         { "attribute['foo'] < 123",         -1,  SDB_AST_LT },
 816         { "attribute['foo'] <= 123",        -1,  SDB_AST_LE },
 817         { "attribute['foo'] = 123",         -1,  SDB_AST_EQ },
 818         { "attribute['foo'] >= 123",        -1,  SDB_AST_GE },
 819         { "attribute['foo'] > 123",         -1,  SDB_AST_GT },
 820         /* datetime expressions */
 821         { "attribute['foo'] = "
 822           "2014-08-16",                     -1,  SDB_AST_EQ },
 823         { "attribute['foo'] = "
 824           "17:23",                          -1,  SDB_AST_EQ },
 825         { "attribute['foo'] = "
 826           "17:23:53",                       -1,  SDB_AST_EQ },
 827         { "attribute['foo'] = "
 828           "17:23:53.123",                   -1,  SDB_AST_EQ },
 829         { "attribute['foo'] = "
 830           "17:23:53.123456789",             -1,  SDB_AST_EQ },
 831         { "attribute['foo'] = "
 832           "2014-08-16 17:23",               -1,  SDB_AST_EQ },
 833         { "attribute['foo'] = "
 834           "2014-08-16 17:23:53",            -1,  SDB_AST_EQ },
 835         /* NULL */
 836         { "attribute['foo'] IS NULL",       -1,  SDB_AST_ISNULL },
 837         { "attribute['foo'] IS NOT NULL",   -1,  SDB_AST_NOT },
 838         /* array expressions */
 839         { "backend < ['a']",                -1,  SDB_AST_LT },
 840         { "backend <= ['a']",               -1,  SDB_AST_LE },
 841         { "backend = ['a']",                -1,  SDB_AST_EQ },
 842         { "backend != ['a']",               -1,  SDB_AST_NE },
 843         { "backend >= ['a']",               -1,  SDB_AST_GE },
 844         { "backend > ['a']",                -1,  SDB_AST_GT },
 845         { "backend &^ ['a']",               -1,  -1 },
 846
 847         /* object field comparison */
 848         { "name < 'a'",                     -1,  SDB_AST_LT },
 849         { "name <= 'a'",                    -1,  SDB_AST_LE },
 850         { "name = 'a'",                     -1,  SDB_AST_EQ },
 851         { "name != 'a'",                    -1,  SDB_AST_NE },
 852         { "name >= 'a'",                    -1,  SDB_AST_GE },
 853         { "name > 'a'",                     -1,  SDB_AST_GT },
 854         { "last_update < 2014-10-01",       -1,  SDB_AST_LT },
 855         { "last_update <= 2014-10-01",      -1,  SDB_AST_LE },
 856         { "last_update = 2014-10-01",       -1,  SDB_AST_EQ },
 857         { "last_update != 2014-10-01",      -1,  SDB_AST_NE },
 858         { "last_update >= 2014-10-01",      -1,  SDB_AST_GE },
 859         { "last_update > 2014-10-01",       -1,  SDB_AST_GT },
 860         { "Last_Update >= 24D",             -1,  SDB_AST_GE },
 861         { "age < 20s",                      -1,  SDB_AST_LT },
 862         { "age <= 20s",                     -1,  SDB_AST_LE },
 863         { "age = 20s",                      -1,  SDB_AST_EQ },
 864         { "age != 20s",                     -1,  SDB_AST_NE },
 865         { "age >= 20s",                     -1,  SDB_AST_GE },
 866         { "age > 20s",                      -1,  SDB_AST_GT },
 867         { "AGE <= 1m",                      -1,  SDB_AST_LE },
 868         { "age > 1M",                       -1,  SDB_AST_GT },
 869         { "age != 20Y",                     -1,  SDB_AST_NE },
 870         { "age <= 2 * interval",            -1,  SDB_AST_LE },
 871         { "interval < 20s",                 -1,  SDB_AST_LT },
 872         { "interval <= 20s",                -1,  SDB_AST_LE },
 873         { "interval = 20s",                 -1,  SDB_AST_EQ },
 874         { "interval != 20s",                -1,  SDB_AST_NE },
 875         { "interval >= 20s",                -1,  SDB_AST_GE },
 876         { "interval > 20s",                 -1,  SDB_AST_GT },
 877         { "'be' IN backend",                -1,  SDB_AST_IN },
 878         { "'be' NOT IN backend",            -1,  SDB_AST_NOT },
 879         { "['a','b'] IN backend",           -1,  SDB_AST_IN },
 880         { "['a','b'] NOT IN backend",       -1,  SDB_AST_NOT },
 881
 882         /* check operator precedence */
 883         { "name = 'name' OR "
 884           "ANY service.name = 'name' AND "
 885           "ANY attribute.name = 'name' OR "
 886           "attribute['foo'] = 'bar'",       -1,  SDB_AST_OR },
 887         { "name = 'name' AND "
 888           "ANY service.name = 'name' AND "
 889           "ANY attribute.name = 'name' OR "
 890           "attribute['foo'] = 'bar'",       -1,  SDB_AST_OR },
 891         { "name = 'name' AND "
 892           "ANY service.name = 'name' OR "
 893           "ANY attribute.name = 'name' AND "
 894           "attribute['foo'] = 'bar'",       -1,  SDB_AST_OR },
 895         { "(name = 'name' OR "
 896           "ANY service.name = 'name') AND "
 897           "(ANY attribute.name = 'name' OR "
 898           "attribute['foo'] = 'bar')",      -1,  SDB_AST_AND },
 899         { "NOT name = 'name' OR "
 900           "ANY service.name = 'name'",      -1,  SDB_AST_OR },
 901         { "NOT name = 'name' OR "
 902           "NOT ANY service.name = 'name'",  -1,  SDB_AST_OR },
 903         { "NOT (name = 'name' OR "
 904           "NOT ANY service.name = 'name')", -1,  SDB_AST_NOT },
 905
 906         /* syntax errors */
 907         { "LIST hosts",                     -1, -1 },
 908         { "foo &^ bar",                     -1, -1 },
 909         { "invalid",                        -1, -1 },
 910 };
 911
 912 START_TEST(test_parse_conditional)
 913 {
 914         sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
 915         sdb_ast_node_t *node;
 916
 917         node = sdb_parser_parse_conditional(parse_conditional_data[_i].expr,
 918                         parse_conditional_data[_i].len, errbuf);
 919
 920         if (parse_conditional_data[_i].expected < 0) {
 921                 fail_unless(node == NULL,
 922                                 "sdb_parser_parse_conditional(%s) = %p; expected: NULL",
 923                                 parse_conditional_data[_i].expr, node);
 924                 sdb_object_deref(SDB_OBJ(node));
 925                 sdb_strbuf_destroy(errbuf);
 926                 return;
 927         }
 928
 929         fail_unless(node != NULL, "sdb_parser_parse_conditional(%s) = NULL; "
 930                         "expected: <cond> (parse error: %s)",
 931                         parse_conditional_data[_i].expr, sdb_strbuf_string(errbuf));
 932         if (node->type == SDB_AST_TYPE_OPERATOR)
 933                 fail_unless(SDB_AST_OP(node)->kind == parse_conditional_data[_i].expected,
 934                                 "sdb_parser_parse_conditional(%s) returned conditional of type %d; "
 935                                 "expected: %d", parse_conditional_data[_i].expr,
 936                                 SDB_AST_OP(node)->kind, parse_conditional_data[_i].expected);
 937         else if (node->type == SDB_AST_TYPE_ITERATOR)
 938                 fail_unless(SDB_AST_ITER(node)->kind == parse_conditional_data[_i].expected,
 939                                 "sdb_parser_parse_conditional(%s) returned conditional of type %d; "
 940                                 "expected: %d", parse_conditional_data[_i].expr,
 941                                 SDB_AST_ITER(node)->kind, parse_conditional_data[_i].expected);
 942
 943         fail_unless(node->data_type == -1,
 944                         "sdb_parser_parse_conditional(%s) returned conditional of data-type %s; "
 945                         "expected: %s", parse_conditional_data[_i].expr,
 946                         SDB_TYPE_TO_STRING(node->data_type), SDB_TYPE_TO_STRING(-1));
 947
 948         sdb_object_deref(SDB_OBJ(node));
 949         sdb_strbuf_destroy(errbuf);
 950 }
 951 END_TEST
 952
 953 struct {
 954         const char *expr;
 955         int len;
 956         int expected;
 957         int data_type;
 958 } parse_arith_data[] = {
 959         /* empty expressions */
 960         { NULL,                   -1, -1, -1 },
 961         { "",                     -1, -1, -1 },
 962
 963         /* constant expressions */
 964         { "'localhost'",          -1, SDB_AST_TYPE_CONST, SDB_TYPE_STRING },
 965         { "123",                  -1, SDB_AST_TYPE_CONST, SDB_TYPE_INTEGER },
 966         { "42.3",                 -1, SDB_AST_TYPE_CONST, SDB_TYPE_DECIMAL },
 967         { "2014-08-16",           -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
 968         { "17:23",                -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
 969         { "17:23:53",             -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
 970         { "17:23:53.123",         -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
 971         { "17:23:53.123456789",   -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
 972         { "2014-08-16 17:23",     -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
 973         { "2014-08-16 17:23:53",  -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
 974         { "10s",                  -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
 975         { "60m",                  -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
 976         { "10Y 24D 1h",           -1, SDB_AST_TYPE_CONST, SDB_TYPE_DATETIME },
 977
 978         /* TODO: the analyzer and/or optimizer should turn these into constants */
 979         { "123 + 456",            -1, SDB_AST_ADD, SDB_TYPE_INTEGER },
 980         { "'foo' || 'bar'",       -1, SDB_AST_CONCAT, SDB_TYPE_STRING },
 981         { "456 - 123",            -1, SDB_AST_SUB, SDB_TYPE_INTEGER },
 982         { "1.2 * 3.4",            -1, SDB_AST_MUL, SDB_TYPE_DECIMAL },
 983         { "1.2 / 3.4",            -1, SDB_AST_DIV, SDB_TYPE_DECIMAL },
 984         { "5 % 2",                -1, SDB_AST_MOD, SDB_TYPE_INTEGER },
 985
 986         /* queryable fields */
 987         { "last_update",          -1, SDB_AST_TYPE_VALUE, SDB_TYPE_DATETIME },
 988         { "AGE",                  -1, SDB_AST_TYPE_VALUE, SDB_TYPE_DATETIME },
 989         { "interval",             -1, SDB_AST_TYPE_VALUE, SDB_TYPE_DATETIME },
 990         { "Last_Update",          -1, SDB_AST_TYPE_VALUE, SDB_TYPE_DATETIME },
 991         { "backend",              -1, SDB_AST_TYPE_VALUE, SDB_TYPE_ARRAY | SDB_TYPE_STRING },
 992
 993         /* attributes */
 994         { "attribute['foo']",     -1, SDB_AST_TYPE_VALUE, -1 },
 995
 996         /* arithmetic expressions */
 997         { "age + age",            -1, SDB_AST_ADD, SDB_TYPE_DATETIME },
 998         { "age - age",            -1, SDB_AST_SUB, SDB_TYPE_DATETIME },
 999         { "age * age",            -1, SDB_AST_MUL, SDB_TYPE_DATETIME },
1000         { "age / age",            -1, SDB_AST_DIV, SDB_TYPE_DATETIME },
1001         { "age \% age",           -1, SDB_AST_MOD, SDB_TYPE_DATETIME },
1002
1003         /* operator precedence */
1004         { "age + age * age",      -1, SDB_AST_ADD, SDB_TYPE_DATETIME },
1005         { "age * age + age",      -1, SDB_AST_ADD, SDB_TYPE_DATETIME },
1006         { "age + age - age",      -1, SDB_AST_SUB, SDB_TYPE_DATETIME },
1007         { "age - age + age",      -1, SDB_AST_ADD, SDB_TYPE_DATETIME },
1008         { "(age + age) * age",    -1, SDB_AST_MUL, SDB_TYPE_DATETIME },
1009         { "age + (age * age)",    -1, SDB_AST_ADD, SDB_TYPE_DATETIME },
1010
1011         /* syntax errors */
1012         { "LIST",                 -1, -1, -1 },
1013         { "foo &^ bar",           -1, -1, -1 },
1014         { "invalid",              -1, -1, -1 },
1015 };
1016
1017 START_TEST(test_parse_arith)
1018 {
1019         sdb_strbuf_t *errbuf = sdb_strbuf_create(64);
1020         sdb_ast_node_t *node;
1021
1022         node = sdb_parser_parse_arith(parse_arith_data[_i].expr,
1023                         parse_arith_data[_i].len, errbuf);
1024
1025         if (parse_arith_data[_i].expected < 0) {
1026                 fail_unless(node == NULL,
1027                                 "sdb_parser_parse_arith(%s) = %p; expected: NULL",
1028                                 parse_arith_data[_i].expr, node);
1029                 sdb_object_deref(SDB_OBJ(node));
1030                 sdb_strbuf_destroy(errbuf);
1031                 return;
1032         }
1033
1034         fail_unless(node != NULL, "sdb_parser_parse_arith(%s) = NULL; "
1035                         "expected: <expr> (parse error: %s)",
1036                         parse_arith_data[_i].expr, sdb_strbuf_string(errbuf));
1037         if (node->type == SDB_AST_TYPE_OPERATOR)
1038                 fail_unless(SDB_AST_OP(node)->kind == parse_arith_data[_i].expected,
1039                                 "sdb_parser_parse_arith(%s) returned expression of type %d; "
1040                                 "expected: %d", parse_arith_data[_i].expr,
1041                                 SDB_AST_OP(node)->kind, parse_arith_data[_i].expected);
1042         else
1043                 fail_unless(node->type == parse_arith_data[_i].expected,
1044                                 "sdb_parser_parse_arith(%s) returned expression of type %d; "
1045                                 "expected: %d", parse_arith_data[_i].expr, node->type,
1046                                 parse_arith_data[_i].expected);
1047
1048         fail_unless(node->data_type == parse_arith_data[_i].data_type,
1049                         "sdb_parser_parse_arith(%s) returned expression of data-type %s; "
1050                         "expected: %s", parse_arith_data[_i].expr,
1051                         SDB_TYPE_TO_STRING(node->data_type),
1052                         SDB_TYPE_TO_STRING(parse_arith_data[_i].data_type));
1053
1054         sdb_object_deref(SDB_OBJ(node));
1055         sdb_strbuf_destroy(errbuf);
1056 }
1057 END_TEST
1058
1059 TEST_MAIN("parser::parser")
1060 {
1061         TCase *tc = tcase_create("core");
1062         TC_ADD_LOOP_TEST(tc, parse);
1063         TC_ADD_LOOP_TEST(tc, parse_conditional);
1064         TC_ADD_LOOP_TEST(tc, parse_arith);
1065         ADD_TCASE(tc);
1066 }
1067 TEST_MAIN_END
1068
1069 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
1070