t/unit/frontend/parser_test.c

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