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