src/parser/analyzer.c

   1 /*
   2  * SysDB - src/parser/analyzer.c
   3  * Copyright (C) 2014-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 #include "sysdb.h"
  29
  30 #include "parser/ast.h"
  31 #include "parser/parser.h"
  32 #include "utils/error.h"
  33 #include "utils/strbuf.h"
  34
  35 #include <assert.h>
  36 #include <stdarg.h>
  37
  38 #define VALID_OBJ_TYPE(t) ((SDB_HOST <= (t)) && ((t) <= SDB_METRIC))
  39
  40 #define FILTER_CONTEXT -1
  41 #define UNSPEC_CONTEXT -2
  42
  43 static int
  44 analyze_node(int context, sdb_ast_node_t *node, sdb_strbuf_t *errbuf);
  45
  46 /*
  47  * error reporting
  48  */
  49
  50 static void
  51 op_error(sdb_strbuf_t *errbuf, sdb_ast_op_t *op, const char *reason)
  52 {
  53         sdb_strbuf_sprintf(errbuf, "Invalid operation %s %s %s (%s)",
  54                         SDB_TYPE_TO_STRING(op->left->data_type),
  55                         SDB_AST_OP_TO_STRING(op->kind),
  56                         SDB_TYPE_TO_STRING(op->right->data_type),
  57                         reason);
  58 } /* op_error */
  59
  60 static void
  61 __attribute__((format(printf, 3, 4)))
  62 iter_error(sdb_strbuf_t *errbuf, sdb_ast_iter_t *iter, const char *reason, ...)
  63 {
  64         char r[1024];
  65         va_list ap;
  66
  67         va_start(ap, reason);
  68         vsnprintf(r, sizeof(r), reason, ap);
  69         va_end(ap);
  70
  71         assert((iter->expr->type == SDB_AST_TYPE_OPERATOR)
  72                         && (! SDB_AST_OP(iter->expr)->left));
  73         sdb_strbuf_sprintf(errbuf, "Invalid iterator %s %s %s %s (%s)",
  74                         SDB_AST_OP_TO_STRING(iter->kind),
  75                         SDB_TYPE_TO_STRING(iter->iter->data_type),
  76                         SDB_AST_OP_TO_STRING(SDB_AST_OP(iter->expr)->kind),
  77                         SDB_TYPE_TO_STRING(SDB_AST_OP(iter->expr)->right->data_type),
  78                         r);
  79 } /* iter_error */
  80
  81 /*
  82  * expression nodes
  83  */
  84
  85 static int
  86 analyze_logical(int context, sdb_ast_op_t *op, sdb_strbuf_t *errbuf)
  87 {
  88         switch (op->kind) {
  89         case SDB_AST_OR:
  90         case SDB_AST_AND:
  91                 if (! SDB_AST_IS_LOGICAL(op->left)) {
  92                         sdb_strbuf_sprintf(errbuf, "Invalid left operand (%s) "
  93                                         "in %s expression", SDB_AST_TYPE_TO_STRING(op->left),
  94                                         SDB_AST_OP_TO_STRING(op->kind));
  95                         return -1;
  96                 }
  97                 if (analyze_node(context, op->left, errbuf))
  98                         return -1;
  99                 /* fallthrough */
 100         case SDB_AST_NOT:
 101                 if (! SDB_AST_IS_LOGICAL(op->right)) {
 102                         sdb_strbuf_sprintf(errbuf, "Invalid right operand (%s) "
 103                                         "in %s expression", SDB_AST_TYPE_TO_STRING(op->right),
 104                                         SDB_AST_OP_TO_STRING(op->kind));
 105                         return -1;
 106                 }
 107                 if (analyze_node(context, op->right, errbuf))
 108                         return -1;
 109                 break;
 110
 111         case SDB_AST_LT:
 112         case SDB_AST_LE:
 113         case SDB_AST_EQ:
 114         case SDB_AST_NE:
 115         case SDB_AST_GE:
 116         case SDB_AST_GT:
 117         {
 118                 if (analyze_node(context, op->left, errbuf))
 119                         return -1;
 120                 if (analyze_node(context, op->right, errbuf))
 121                         return -1;
 122
 123                 if ((op->left->data_type > 0) && (op->right->data_type > 0)) {
 124                         if (op->left->data_type == op->right->data_type)
 125                                 return 0;
 126                         op_error(errbuf, op, "type mismatch");
 127                         return -1;
 128                 }
 129                 if ((op->left->data_type > 0) && (op->left->data_type & SDB_TYPE_ARRAY)) {
 130                         op_error(errbuf, op, "array not allowed");
 131                         return -1;
 132                 }
 133                 if ((op->right->data_type > 0) && (op->right->data_type & SDB_TYPE_ARRAY)) {
 134                         op_error(errbuf, op, "array not allowed");
 135                         return -1;
 136                 }
 137                 break;
 138         }
 139
 140         case SDB_AST_REGEX:
 141         case SDB_AST_NREGEX:
 142                 if (analyze_node(context, op->left, errbuf))
 143                         return -1;
 144                 if (analyze_node(context, op->right, errbuf))
 145                         return -1;
 146
 147                 /* all types are supported for the left operand
 148                  * TODO: introduce a cast operator if it's not a string */
 149                 if ((op->right->data_type > 0)
 150                                 && (op->right->data_type != SDB_TYPE_REGEX)
 151                                 && (op->right->data_type != SDB_TYPE_STRING)) {
 152                         op_error(errbuf, op, "invalid regex");
 153                         return -1;
 154                 }
 155                 break;
 156
 157         case SDB_AST_ISNULL:
 158         case SDB_AST_ISTRUE:
 159         case SDB_AST_ISFALSE:
 160                 if (analyze_node(context, op->right, errbuf))
 161                         return -1;
 162                 break;
 163
 164         case SDB_AST_IN:
 165                 if (analyze_node(context, op->left, errbuf))
 166                         return -1;
 167                 if (analyze_node(context, op->right, errbuf))
 168                         return -1;
 169
 170                 if ((op->right->data_type > 0) && (! (op->right->data_type & SDB_TYPE_ARRAY))) {
 171                         op_error(errbuf, op, "array expected");
 172                         return -1;
 173                 }
 174                 /* the left operand may be a scalar or an array but the element
 175                  * type has to match */
 176                 if ((op->left->data_type > 0) && (op->right->data_type > 0)
 177                                 && ((op->left->data_type & 0xff) != (op->right->data_type & 0xff))) {
 178                         op_error(errbuf, op, "type mismatch");
 179                         return -1;
 180                 }
 181                 break;
 182
 183         default:
 184                 sdb_strbuf_sprintf(errbuf, "Unknown operand type %d", op->kind);
 185                 return -1;
 186         }
 187         return 0;
 188 } /* analyze_logical */
 189
 190 static int
 191 analyze_arith(int context, sdb_ast_op_t *op, sdb_strbuf_t *errbuf)
 192 {
 193         if (analyze_node(context, op->left, errbuf))
 194                 return -1;
 195         if (analyze_node(context, op->right, errbuf))
 196                 return -1;
 197         SDB_AST_NODE(op)->data_type = sdb_data_expr_type(SDB_AST_OP_TO_DATA_OP(op->kind),
 198                         op->left->data_type, op->right->data_type);
 199
 200         if ((op->left->data_type > 0) && (op->right->data_type > 0)
 201                         && (SDB_AST_NODE(op)->data_type <= 0)) {
 202                 op_error(errbuf, op, "type mismatch");
 203                 return -1;
 204         }
 205
 206         /* TODO: replace constant arithmetic operations with a constant value */
 207         return 0;
 208 } /* analyze_arith */
 209
 210 static int
 211 analyze_iter(int context, sdb_ast_iter_t *iter, sdb_strbuf_t *errbuf)
 212 {
 213         sdb_ast_const_t c = SDB_AST_CONST_INIT;
 214         int iter_context = context;
 215         int status;
 216
 217         if (iter->iter->type == SDB_AST_TYPE_TYPED)
 218                 iter_context = SDB_AST_TYPED(iter->iter)->type;
 219
 220         if (analyze_node(iter_context, iter->iter, errbuf))
 221                 return -1;
 222         /* TODO: support other setups as well */
 223         assert((iter->expr->type == SDB_AST_TYPE_OPERATOR)
 224                         && (! SDB_AST_OP(iter->expr)->left));
 225         /* determine the data-type for better error messages */
 226         analyze_node(iter_context, SDB_AST_OP(iter->expr)->right, NULL);
 227
 228         if (iter->iter->type == SDB_AST_TYPE_TYPED) {
 229                 int iter_type = SDB_AST_TYPED(iter->iter)->type;
 230
 231                 c.value.type = iter->iter->data_type;
 232
 233                 if (iter_type == SDB_ATTRIBUTE) {
 234                         /* attributes are always iterable */
 235                 }
 236                 else if ((context != SDB_HOST) && (context != SDB_SERVICE)
 237                                 && (context != SDB_METRIC) && (context != UNSPEC_CONTEXT)) {
 238                         iter_error(errbuf, iter, "%s not iterable in %s context",
 239                                         SDB_STORE_TYPE_TO_NAME(iter_type),
 240                                         SDB_STORE_TYPE_TO_NAME(context));
 241                         return -1;
 242                 }
 243
 244                 if ((context == iter_type)
 245                                 || ((iter_type != SDB_SERVICE)
 246                                         && (iter_type != SDB_METRIC)
 247                                         && (iter_type != SDB_ATTRIBUTE))
 248                                 || ((context == SDB_SERVICE)
 249                                         && (iter_type == SDB_METRIC))
 250                                 || ((context == SDB_METRIC)
 251                                         && (iter_type == SDB_SERVICE))) {
 252                         iter_error(errbuf, iter, "%s not iterable in %s context",
 253                                         SDB_STORE_TYPE_TO_NAME(iter_type),
 254                                         SDB_STORE_TYPE_TO_NAME(context));
 255                         return -1;
 256                 }
 257         }
 258         else if (iter->iter->type == SDB_AST_TYPE_VALUE) {
 259                 int iter_type = SDB_AST_VALUE(iter->iter)->type;
 260
 261                 c.value.type = iter->iter->data_type & 0xff;
 262
 263                 if (iter_type != SDB_FIELD_BACKEND) {
 264                         iter_error(errbuf, iter, "%s not iterable in %s context",
 265                                         (iter_type == SDB_ATTRIBUTE)
 266                                                 ? "attribute"
 267                                                 : SDB_FIELD_TO_NAME(iter_type),
 268                                         SDB_STORE_TYPE_TO_NAME(context));
 269                         return -1;
 270                 }
 271         }
 272         else if (iter->iter->type == SDB_AST_TYPE_CONST) {
 273                 c.value.type = iter->iter->data_type & 0xff;
 274
 275                 if (! (SDB_AST_CONST(iter->iter)->value.type & SDB_TYPE_ARRAY)) {
 276                         iter_error(errbuf, iter, "%s not iterable",
 277                                         SDB_TYPE_TO_STRING(SDB_AST_CONST(iter->iter)->value.type));
 278                         return -1;
 279                 }
 280         }
 281         else {
 282                 /* TODO: if we know the data-type of iter->iter and it's an array,
 283                  * we should support an iterator for it as well */
 284                 iter_error(errbuf, iter, "%s expression not iterable",
 285                                 SDB_AST_TYPE_TO_STRING(iter->iter));
 286                 return -1;
 287         }
 288
 289         SDB_AST_OP(iter->expr)->left = SDB_AST_NODE(&c);
 290         status = analyze_node(context, iter->expr, errbuf);
 291         SDB_AST_OP(iter->expr)->left = NULL;
 292         if (status)
 293                 return -1;
 294         return 0;
 295 } /* analyze_iter */
 296
 297 static int
 298 analyze_const(int __attribute__((unused)) context, sdb_ast_const_t *c,
 299                 sdb_strbuf_t __attribute__((unused)) *errbuf)
 300 {
 301         SDB_AST_NODE(c)->data_type = c->value.type;
 302         return 0;
 303 } /* analyze_const */
 304
 305 static int
 306 analyze_value(int context, sdb_ast_value_t *v, sdb_strbuf_t *errbuf)
 307 {
 308         if (v->type != SDB_ATTRIBUTE)
 309                 SDB_AST_NODE(v)->data_type = SDB_FIELD_TYPE(v->type);
 310
 311         if ((v->type != SDB_ATTRIBUTE) && v->name) {
 312                 sdb_strbuf_sprintf(errbuf, "Invalid expression %s[%s]",
 313                                 SDB_FIELD_TO_NAME(v->type), v->name);
 314                 return -1;
 315         }
 316         else if ((v->type == SDB_ATTRIBUTE) && (! v->name)) {
 317                 sdb_strbuf_sprintf(errbuf, "Invalid expression attribute[] "
 318                                 "(missing name)");
 319                 return -1;
 320         }
 321
 322         if (context != UNSPEC_CONTEXT) {
 323                 /* skip these checks if we don't know the context; it's up to the
 324                  * caller to check again once the right context information is
 325                  * available */
 326                 if ((context != SDB_ATTRIBUTE) && (v->type == SDB_FIELD_VALUE)) {
 327                         sdb_strbuf_sprintf(errbuf, "Invalid expression %s.value",
 328                                         SDB_FIELD_TO_NAME(context));
 329                         return -1;
 330                 }
 331                 if ((context != SDB_METRIC) && (v->type == SDB_FIELD_TIMESERIES)) {
 332                         sdb_strbuf_sprintf(errbuf, "Invalid expression %s.timeseries",
 333                                         SDB_FIELD_TO_NAME(context));
 334                         return -1;
 335                 }
 336         }
 337         return 0;
 338 } /* analyze_value */
 339
 340 static int
 341 analyze_typed(int context, sdb_ast_typed_t *t, sdb_strbuf_t *errbuf)
 342 {
 343         if ((t->expr->type != SDB_AST_TYPE_VALUE)
 344                         && (t->expr->type != SDB_AST_TYPE_TYPED)) {
 345                 sdb_strbuf_sprintf(errbuf, "Invalid expression %s.%s",
 346                                 SDB_STORE_TYPE_TO_NAME(t->type),
 347                                 SDB_AST_TYPE_TO_STRING(t->expr));
 348                 return -1;
 349         }
 350         if (analyze_node(t->type, t->expr, errbuf))
 351                 return -1;
 352         SDB_AST_NODE(t)->data_type = t->expr->data_type;
 353
 354         if ((t->type != SDB_ATTRIBUTE) && (! VALID_OBJ_TYPE(t->type))) {
 355                 sdb_strbuf_sprintf(errbuf, "Invalid expression %#x.%s",
 356                                 t->type, SDB_AST_TYPE_TO_STRING(t->expr));
 357                 return -1;
 358         }
 359
 360         /* self-references are allowed and services and metrics may reference
 361          * their parent host; everything may reference attributes */
 362         if ((context != t->type) && (context > 0)
 363                         && (((context != SDB_SERVICE) && (context != SDB_METRIC))
 364                                 || (t->type != SDB_HOST))
 365                         && (t->type != SDB_ATTRIBUTE)) {
 366                 sdb_strbuf_sprintf(errbuf, "Invalid expression %s.%s in %s context",
 367                                 SDB_STORE_TYPE_TO_NAME(t->type),
 368                                 SDB_AST_TYPE_TO_STRING(t->expr),
 369                                 context == -1 ? "generic" : SDB_STORE_TYPE_TO_NAME(context));
 370                 return -1;
 371         }
 372         return 0;
 373 } /* analyze_typed */
 374
 375 static int
 376 analyze_node(int context, sdb_ast_node_t *node, sdb_strbuf_t *errbuf)
 377 {
 378         if (! node) {
 379                 sdb_strbuf_sprintf(errbuf, "Empty AST node");
 380                 return -1;
 381         }
 382
 383         /* unknown by default */
 384         node->data_type = -1;
 385
 386         if ((node->type == SDB_AST_TYPE_OPERATOR)
 387                         && (SDB_AST_IS_LOGICAL(node)))
 388                 return analyze_logical(context, SDB_AST_OP(node), errbuf);
 389         else if ((node->type == SDB_AST_TYPE_OPERATOR)
 390                         && (SDB_AST_IS_ARITHMETIC(node)))
 391                 return analyze_arith(context, SDB_AST_OP(node), errbuf);
 392         else if (node->type == SDB_AST_TYPE_ITERATOR)
 393                 return analyze_iter(context, SDB_AST_ITER(node), errbuf);
 394         else if (node->type == SDB_AST_TYPE_CONST)
 395                 return analyze_const(context, SDB_AST_CONST(node), errbuf);
 396         else if (node->type == SDB_AST_TYPE_VALUE)
 397                 return analyze_value(context, SDB_AST_VALUE(node), errbuf);
 398         else if (node->type == SDB_AST_TYPE_TYPED)
 399                 return analyze_typed(context, SDB_AST_TYPED(node), errbuf);
 400
 401         sdb_strbuf_sprintf(errbuf, "Invalid expression node "
 402                         "of type %#x", node->type);
 403         return -1;
 404 } /* analyze_node */
 405
 406 /*
 407  * top level / command nodes
 408  */
 409
 410 static int
 411 analyze_fetch(sdb_ast_fetch_t *fetch, sdb_strbuf_t *errbuf)
 412 {
 413         if (! VALID_OBJ_TYPE(fetch->obj_type)) {
 414                 sdb_strbuf_sprintf(errbuf, "Invalid object type %#x "
 415                                 "in FETCH command", fetch->obj_type);
 416                 return -1;
 417         }
 418         if (! fetch->name) {
 419                 sdb_strbuf_sprintf(errbuf, "Missing object name in "
 420                                 "FETCH %s command", SDB_STORE_TYPE_TO_NAME(fetch->obj_type));
 421                 return -1;
 422         }
 423
 424         if ((fetch->obj_type == SDB_HOST) && fetch->hostname) {
 425                 sdb_strbuf_sprintf(errbuf, "Unexpected parent hostname '%s' "
 426                                 "in FETCH HOST command", fetch->hostname);
 427                 return -1;
 428         }
 429         else if ((fetch->obj_type != SDB_HOST) && (! fetch->hostname)) {
 430                 sdb_strbuf_sprintf(errbuf, "Missing parent hostname for '%s' "
 431                                 "in FETCH %s command", fetch->name,
 432                                 SDB_STORE_TYPE_TO_NAME(fetch->obj_type));
 433                 return -1;
 434         }
 435
 436         if (fetch->filter)
 437                 return analyze_node(FILTER_CONTEXT, fetch->filter, errbuf);
 438         return 0;
 439 } /* analyze_fetch */
 440
 441 static int
 442 analyze_list(sdb_ast_list_t *list, sdb_strbuf_t *errbuf)
 443 {
 444         if (! VALID_OBJ_TYPE(list->obj_type)) {
 445                 sdb_strbuf_sprintf(errbuf, "Invalid object type %#x "
 446                                 "in LIST command", list->obj_type);
 447                 return -1;
 448         }
 449         if (list->filter)
 450                 return analyze_node(FILTER_CONTEXT, list->filter, errbuf);
 451         return 0;
 452 } /* analyze_list */
 453
 454 static int
 455 analyze_lookup(sdb_ast_lookup_t *lookup, sdb_strbuf_t *errbuf)
 456 {
 457         if (! VALID_OBJ_TYPE(lookup->obj_type)) {
 458                 sdb_strbuf_sprintf(errbuf, "Invalid object type %#x "
 459                                 "in LOOKUP command", lookup->obj_type);
 460                 return -1;
 461         }
 462         if (lookup->matcher)
 463                 if (analyze_node(lookup->obj_type, lookup->matcher, errbuf))
 464                         return -1;
 465         if (lookup->filter)
 466                 return analyze_node(FILTER_CONTEXT, lookup->filter, errbuf);
 467         return 0;
 468 } /* analyze_lookup */
 469
 470 static int
 471 analyze_store(sdb_ast_store_t *st, sdb_strbuf_t *errbuf)
 472 {
 473         if ((st->obj_type != SDB_ATTRIBUTE)
 474                         && (! VALID_OBJ_TYPE(st->obj_type))) {
 475                 sdb_strbuf_sprintf(errbuf, "Invalid object type %#x "
 476                                 "in STORE command", st->obj_type);
 477                 return -1;
 478         }
 479         if (! st->name) {
 480                 sdb_strbuf_sprintf(errbuf, "Missing object name in "
 481                                 "STORE %s command", SDB_STORE_TYPE_TO_NAME(st->obj_type));
 482                 return -1;
 483         }
 484
 485         if ((st->obj_type == SDB_HOST) && st->hostname) {
 486                 sdb_strbuf_sprintf(errbuf, "Unexpected parent hostname '%s' "
 487                                 "in STORE HOST command", st->hostname);
 488                 return -1;
 489         }
 490         else if ((st->obj_type != SDB_HOST) && (! st->hostname)) {
 491                 sdb_strbuf_sprintf(errbuf, "Missing parent hostname for '%s' "
 492                                 "in STORE %s command", st->name,
 493                                 SDB_STORE_TYPE_TO_NAME(st->obj_type));
 494                 return -1;
 495         }
 496
 497         if (st->obj_type == SDB_ATTRIBUTE) {
 498                 if ((st->parent_type <= 0) && st->parent) {
 499                         sdb_strbuf_sprintf(errbuf, "Unexpected parent hostname '%s' "
 500                                         "in STORE %s command", st->parent,
 501                                         SDB_STORE_TYPE_TO_NAME(st->obj_type));
 502                         return -1;
 503                 }
 504                 else if (st->parent_type > 0) {
 505                         if (! VALID_OBJ_TYPE(st->parent_type)) {
 506                                 sdb_strbuf_sprintf(errbuf, "Invalid parent type %#x "
 507                                                 "in STORE %s command", st->parent_type,
 508                                                 SDB_STORE_TYPE_TO_NAME(st->obj_type));
 509                                 return -1;
 510                         }
 511                         if (! st->parent) {
 512                                 sdb_strbuf_sprintf(errbuf, "Missing %s parent name "
 513                                                 "in STORE %s command",
 514                                                 SDB_STORE_TYPE_TO_NAME(st->parent_type),
 515                                                 SDB_STORE_TYPE_TO_NAME(st->obj_type));
 516                                 return -1;
 517                         }
 518                 }
 519         }
 520         else if ((st->parent_type > 0) || st->parent) {
 521                 sdb_strbuf_sprintf(errbuf, "Unexpected %s parent name '%s' "
 522                                 "in STORE %s command",
 523                                 SDB_STORE_TYPE_TO_NAME(st->parent_type),
 524                                 st->parent ? st->parent : "<unknown>",
 525                                 SDB_STORE_TYPE_TO_NAME(st->obj_type));
 526                 return -1;
 527         }
 528
 529         if (st->obj_type == SDB_METRIC) {
 530                 if ((! st->store_type) != (! st->store_id)) {
 531                         sdb_strbuf_sprintf(errbuf, "Incomplete metric store %s %s "
 532                                         "in STORE METRIC command",
 533                                         st->store_type ? st->store_type : "<unknown>",
 534                                         st->store_id ? st->store_id : "<unknown>");
 535                         return -1;
 536                 }
 537         }
 538         else if (st->store_type || st->store_id) {
 539                 sdb_strbuf_sprintf(errbuf, "Unexpected metric store %s %s "
 540                                 "in STORE %s command",
 541                                 st->store_type ? st->store_type : "<unknown>",
 542                                 st->store_id ? st->store_id : "<unknown>",
 543                                 SDB_STORE_TYPE_TO_NAME(st->obj_type));
 544                 return -1;
 545         }
 546
 547         if ((! (st->obj_type == SDB_ATTRIBUTE))
 548                         && (st->value.type != SDB_TYPE_NULL)) {
 549                 char v_str[sdb_data_format(&st->value, NULL, 0, SDB_DOUBLE_QUOTED) + 1];
 550                 sdb_data_format(&st->value, v_str, sizeof(v_str), SDB_DOUBLE_QUOTED);
 551                 sdb_strbuf_sprintf(errbuf, "Unexpected value %s in STORE %s command",
 552                                 v_str, SDB_STORE_TYPE_TO_NAME(st->obj_type));
 553                 return -1;
 554         }
 555         return 0;
 556 } /* analyze_store */
 557
 558 static int
 559 analyze_timeseries(sdb_ast_timeseries_t *ts, sdb_strbuf_t *errbuf)
 560 {
 561         if (! ts->hostname) {
 562                 sdb_strbuf_sprintf(errbuf, "Missing hostname in STORE command");
 563                 return -1;
 564         }
 565         if (! ts->metric) {
 566                 sdb_strbuf_sprintf(errbuf, "Missing metric name in STORE command");
 567                 return -1;
 568         }
 569         if (ts->end <= ts->start) {
 570                 char start_str[64], end_str[64];
 571                 sdb_strftime(start_str, sizeof(start_str), ts->start);
 572                 sdb_strftime(end_str, sizeof(end_str), ts->end);
 573                 sdb_strbuf_sprintf(errbuf, "Start time (%s) greater than "
 574                                 "end time (%s) in STORE command", start_str, end_str);
 575                 return -1;
 576         }
 577         return 0;
 578 } /* analyze_timeseries */
 579
 580 /*
 581  * public API
 582  */
 583
 584 int
 585 sdb_parser_analyze(sdb_ast_node_t *node, sdb_strbuf_t *errbuf)
 586 {
 587         if (! node) {
 588                 sdb_strbuf_sprintf(errbuf, "Empty AST node");
 589                 return -1;
 590         }
 591
 592         /* top-level nodes don't have a type */
 593         node->data_type = -1;
 594
 595         if (node->type == SDB_AST_TYPE_FETCH)
 596                 return analyze_fetch(SDB_AST_FETCH(node), errbuf);
 597         else if (node->type == SDB_AST_TYPE_LIST)
 598                 return analyze_list(SDB_AST_LIST(node), errbuf);
 599         else if (node->type == SDB_AST_TYPE_LOOKUP)
 600                 return analyze_lookup(SDB_AST_LOOKUP(node), errbuf);
 601         else if (node->type == SDB_AST_TYPE_STORE)
 602                 return analyze_store(SDB_AST_STORE(node), errbuf);
 603         else if (node->type == SDB_AST_TYPE_TIMESERIES)
 604                 return analyze_timeseries(SDB_AST_TIMESERIES(node), errbuf);
 605
 606         sdb_strbuf_sprintf(errbuf, "Invalid top-level AST node "
 607                         "of type %#x", node->type);
 608         return -1;
 609 } /* sdb_parser_analyze */
 610
 611 int
 612 sdb_parser_analyze_conditional(sdb_ast_node_t *node, sdb_strbuf_t *errbuf)
 613 {
 614         if (! node) {
 615                 sdb_strbuf_sprintf(errbuf, "Empty conditional node");
 616                 return -1;
 617         }
 618         if (! SDB_AST_IS_LOGICAL(node)) {
 619                 sdb_strbuf_sprintf(errbuf, "Not a conditional node (got %s)",
 620                                 SDB_AST_TYPE_TO_STRING(node));
 621                 return -1;
 622         }
 623         return analyze_node(UNSPEC_CONTEXT, node, errbuf);
 624 } /* sdb_parser_analyze_conditional */
 625
 626 int
 627 sdb_parser_analyze_arith(sdb_ast_node_t *node, sdb_strbuf_t *errbuf)
 628 {
 629         if (! node) {
 630                 sdb_strbuf_sprintf(errbuf, "Empty arithmetic node");
 631                 return -1;
 632         }
 633         if (! SDB_AST_IS_ARITHMETIC(node)) {
 634                 sdb_strbuf_sprintf(errbuf, "Not an arithmetic node (got %s)",
 635                                 SDB_AST_TYPE_TO_STRING(node));
 636                 return -1;
 637         }
 638         return analyze_node(UNSPEC_CONTEXT, node, errbuf);
 639 } /* sdb_parser_analyze_arith */
 640
 641 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */
 642