dlls/msi/sql.y

   1 %{
   2
   3 /*
   4  * Implementation of the Microsoft Installer (msi.dll)
   5  *
   6  * Copyright 2002-2004 Mike McCormack for CodeWeavers
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23
  24 #include "config.h"
  25
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "query.h"
  33 #include "wine/debug.h"
  34 #include "wine/unicode.h"
  35
  36 #define YYLEX_PARAM info
  37 #define YYPARSE_PARAM info
  38
  39 extern int SQL_error(const char *str);
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  42
  43 typedef struct tag_SQL_input
  44 {
  45     MSIDATABASE *db;
  46     LPCWSTR command;
  47     DWORD n, len;
  48     MSIVIEW **view;  /* view structure for the resulting query */
  49 } SQL_input;
  50
  51 static LPWSTR SQL_getstring( struct sql_str *str );
  52 static INT SQL_getint( SQL_input *sql );
  53 static int SQL_lex( void *SQL_lval, SQL_input *info);
  54
  55 static MSIVIEW *do_one_select( MSIDATABASE *db, MSIVIEW *in,
  56                                string_list *columns );
  57 static MSIVIEW *do_order_by( MSIDATABASE *db, MSIVIEW *in,
  58                              string_list *columns );
  59
  60 static BOOL SQL_MarkPrimaryKeys( create_col_info *cols,
  61                                  string_list *keys);
  62
  63 static struct expr * EXPR_complex( struct expr *l, UINT op, struct expr *r );
  64 static struct expr * EXPR_column( LPWSTR );
  65 static struct expr * EXPR_ival( struct sql_str *);
  66 static struct expr * EXPR_sval( struct sql_str *);
  67 static struct expr * EXPR_wildcard();
  68
  69 %}
  70
  71 %pure-parser
  72
  73 %union
  74 {
  75     struct sql_str str;
  76     LPWSTR string;
  77     string_list *column_list;
  78     value_list *val_list;
  79     MSIVIEW *query;
  80     struct expr *expr;
  81     USHORT column_type;
  82     create_col_info *column_info;
  83 }
  84
  85 %token TK_ABORT TK_AFTER TK_AGG_FUNCTION TK_ALL TK_AND TK_AS TK_ASC
  86 %token TK_BEFORE TK_BEGIN TK_BETWEEN TK_BITAND TK_BITNOT TK_BITOR TK_BY
  87 %token TK_CASCADE TK_CASE TK_CHAR TK_CHECK TK_CLUSTER TK_COLLATE TK_COLUMN
  88 %token TK_COMMA TK_COMMENT TK_COMMIT TK_CONCAT TK_CONFLICT
  89 %token TK_CONSTRAINT TK_COPY TK_CREATE
  90 %token TK_DEFAULT TK_DEFERRABLE TK_DEFERRED TK_DELETE TK_DELIMITERS TK_DESC
  91 %token TK_DISTINCT TK_DOT TK_DROP TK_EACH
  92 %token TK_ELSE TK_END TK_END_OF_FILE TK_EQ TK_EXCEPT TK_EXPLAIN
  93 %token TK_FAIL TK_FLOAT TK_FOR TK_FOREIGN TK_FROM TK_FUNCTION
  94 %token TK_GE TK_GLOB TK_GROUP TK_GT
  95 %token TK_HAVING TK_HOLD
  96 %token TK_IGNORE TK_ILLEGAL TK_IMMEDIATE TK_IN TK_INDEX TK_INITIALLY
  97 %token <str> TK_ID
  98 %token TK_INSERT TK_INSTEAD TK_INT
  99 %token <str> TK_INTEGER
 100 %token TK_INTERSECT TK_INTO TK_IS
 101 %token TK_ISNULL
 102 %token TK_JOIN TK_JOIN_KW
 103 %token TK_KEY
 104 %token TK_LE TK_LIKE TK_LIMIT TK_LONG TK_LONGCHAR TK_LP TK_LSHIFT TK_LT
 105 %token TK_LOCALIZABLE
 106 %token TK_MATCH TK_MINUS
 107 %token TK_NE TK_NOT TK_NOTNULL TK_NULL
 108 %token TK_OBJECT TK_OF TK_OFFSET TK_ON TK_OR TK_ORACLE_OUTER_JOIN TK_ORDER
 109 %token TK_PLUS TK_PRAGMA TK_PRIMARY
 110 %token TK_RAISE TK_REFERENCES TK_REM TK_REPLACE TK_RESTRICT TK_ROLLBACK
 111 %token TK_ROW TK_RP TK_RSHIFT
 112 %token TK_SELECT TK_SEMI TK_SET TK_SHORT TK_SLASH TK_SPACE TK_STAR TK_STATEMENT
 113 %token <str> TK_STRING
 114 %token TK_TABLE TK_TEMP TK_THEN TK_TRANSACTION TK_TRIGGER
 115 %token TK_UMINUS TK_UNCLOSED_STRING TK_UNION TK_UNIQUE
 116 %token TK_UPDATE TK_UPLUS TK_USING
 117 %token TK_VACUUM TK_VALUES TK_VIEW
 118 %token TK_WHEN TK_WHERE TK_WILDCARD
 119
 120 /*
 121  * These are extra tokens used by the lexer but never seen by the
 122  * parser.  We put them in a rule so that the parser generator will
 123  * add them to the parse.h output file.
 124  *
 125  */
 126 %nonassoc END_OF_FILE ILLEGAL SPACE UNCLOSED_STRING COMMENT FUNCTION
 127           COLUMN AGG_FUNCTION.
 128
 129 %type <string> column table string_or_id
 130 %type <column_list> selcollist
 131 %type <query> from unorderedsel oneselect onequery onecreate oneinsert
 132 %type <expr> expr val column_val const_val
 133 %type <column_type> column_type data_type data_type_l data_count
 134 %type <column_info> column_def table_def
 135 %type <val_list> constlist
 136
 137 %%
 138
 139 onequery:
 140     oneselect
 141     {
 142         SQL_input* sql = (SQL_input*) info;
 143         *sql->view = $1;
 144     }
 145   | onecreate
 146     {
 147         SQL_input* sql = (SQL_input*) info;
 148         *sql->view = $1;
 149     }
 150   | oneinsert
 151     {
 152         SQL_input* sql = (SQL_input*) info;
 153         *sql->view = $1;
 154     }
 155     ;
 156
 157 oneinsert:
 158     TK_INSERT TK_INTO table TK_LP selcollist TK_RP TK_VALUES TK_LP constlist TK_RP
 159     {
 160         SQL_input *sql = (SQL_input*) info;
 161         MSIVIEW *insert = NULL;
 162
 163         INSERT_CreateView( sql->db, &insert, $3, $5, $9, FALSE );
 164         $$ = insert;
 165     }
 166   | TK_INSERT TK_INTO table TK_LP selcollist TK_RP TK_VALUES TK_LP constlist TK_RP TK_TEMP
 167     {
 168         SQL_input *sql = (SQL_input*) info;
 169         MSIVIEW *insert = NULL;
 170
 171         INSERT_CreateView( sql->db, &insert, $3, $5, $9, TRUE );
 172         $$ = insert;
 173     }
 174     ;
 175
 176 onecreate:
 177     TK_CREATE TK_TABLE table TK_LP table_def TK_RP
 178         {
 179             SQL_input* sql = (SQL_input*) info;
 180             MSIVIEW *create;
 181
 182             if( !$5 )
 183                 YYABORT;
 184             CREATE_CreateView( sql->db, &create, $3, $5, FALSE );
 185             $$ = create;
 186         }
 187   | TK_CREATE TK_TABLE table TK_LP table_def TK_RP TK_HOLD
 188         {
 189             SQL_input* sql = (SQL_input*) info;
 190             MSIVIEW *create;
 191
 192             if( !$5 )
 193                 YYABORT;
 194             CREATE_CreateView( sql->db, &create, $3, $5, TRUE );
 195             $$ = create;
 196         }
 197     ;
 198
 199 table_def:
 200     column_def TK_PRIMARY TK_KEY selcollist
 201         {
 202             if( SQL_MarkPrimaryKeys( $1, $4 ) )
 203                 $$ = $1;
 204             else
 205                 $$ = NULL;
 206         }
 207     ;
 208
 209 column_def:
 210     column_def TK_COMMA column column_type
 211         {
 212             create_col_info *ci;
 213
 214             for( ci = $1; ci->next; ci = ci->next )
 215                 ;
 216
 217             ci->next = HeapAlloc( GetProcessHeap(), 0, sizeof *$$ );
 218             if( !ci->next )
 219             {
 220                 /* FIXME: free $1 */
 221                 YYABORT;
 222             }
 223             ci->next->colname = $3;
 224             ci->next->type = $4;
 225             ci->next->next = NULL;
 226
 227             $$ = $1;
 228         }
 229   | column column_type
 230         {
 231             $$ = HeapAlloc( GetProcessHeap(), 0, sizeof *$$ );
 232             if( ! $$ )
 233                 YYABORT;
 234             $$->colname = $1;
 235             $$->type = $2;
 236             $$->next = NULL;
 237         }
 238     ;
 239
 240 column_type:
 241     data_type_l
 242         {
 243             $$ = $1 | MSITYPE_VALID;
 244         }
 245   | data_type_l TK_LOCALIZABLE
 246         {
 247             FIXME("LOCALIZABLE ignored\n");
 248             $$ = $1 | MSITYPE_VALID;
 249         }
 250     ;
 251
 252 data_type_l:
 253     data_type
 254         {
 255             $$ |= MSITYPE_NULLABLE;
 256         }
 257   | data_type TK_NOT TK_NULL
 258         {
 259             $$ = $1;
 260         }
 261     ;
 262
 263 data_type:
 264     TK_CHAR
 265         {
 266             $$ = MSITYPE_STRING | 1;
 267         }
 268   | TK_CHAR TK_LP data_count TK_RP
 269         {
 270             $$ = MSITYPE_STRING | 0x400 | $3;
 271         }
 272   | TK_LONGCHAR
 273         {
 274             $$ = 2;
 275         }
 276   | TK_SHORT
 277         {
 278             $$ = 2;
 279         }
 280   | TK_INT
 281         {
 282             $$ = 2;
 283         }
 284   | TK_LONG
 285         {
 286             $$ = 4;
 287         }
 288   | TK_OBJECT
 289         {
 290             $$ = 0;
 291         }
 292     ;
 293
 294 data_count:
 295     TK_INTEGER
 296         {
 297             SQL_input* sql = (SQL_input*) info;
 298             int val = SQL_getint(sql);
 299             if( ( val > 255 ) || ( val < 0 ) )
 300                 YYABORT;
 301             $$ = val;
 302         }
 303     ;
 304
 305 oneselect:
 306     unorderedsel TK_ORDER TK_BY selcollist
 307         {
 308             SQL_input* sql = (SQL_input*) info;
 309
 310             if( !$1 )
 311                 YYABORT;
 312             if( $4 )
 313                 $$ = do_order_by( sql->db, $1, $4 );
 314             else
 315                 $$ = $1;
 316         }
 317   | unorderedsel
 318     ;
 319
 320 unorderedsel:
 321     TK_SELECT selcollist from
 322         {
 323             SQL_input* sql = (SQL_input*) info;
 324             if( !$3 )
 325                 YYABORT;
 326             if( $2 )
 327                 $$ = do_one_select( sql->db, $3, $2 );
 328             else
 329                 $$ = $3;
 330         }
 331   | TK_SELECT TK_DISTINCT selcollist from
 332         {
 333             SQL_input* sql = (SQL_input*) info;
 334             MSIVIEW *view = $4;
 335
 336             if( !view )
 337                 YYABORT;
 338             if( $3 )
 339                 view = do_one_select( sql->db, view, $3 );
 340             DISTINCT_CreateView( sql->db, & $$, view );
 341         }
 342     ;
 343
 344 selcollist:
 345     column
 346         {
 347             string_list *list;
 348
 349             list = HeapAlloc( GetProcessHeap(), 0, sizeof *list );
 350             if( !list )
 351                 YYABORT;
 352             list->string = $1;
 353             list->next = NULL;
 354
 355             $$ = list;
 356             TRACE("Collist %s\n",debugstr_w($$->string));
 357         }
 358   | column TK_COMMA selcollist
 359         {
 360             string_list *list;
 361
 362             list = HeapAlloc( GetProcessHeap(), 0, sizeof *list );
 363             if( !list )
 364                 YYABORT;
 365             list->string = $1;
 366             list->next = $3;
 367
 368             $$ = list;
 369             TRACE("From table: %s\n",debugstr_w($$->string));
 370         }
 371   | TK_STAR
 372         {
 373             $$ = NULL;
 374         }
 375     ;
 376
 377 from:
 378     TK_FROM table
 379         {
 380             SQL_input* sql = (SQL_input*) info;
 381
 382             $$ = NULL;
 383             TRACE("From table: %s\n",debugstr_w($2));
 384             TABLE_CreateView( sql->db, $2, & $$ );
 385         }
 386   | TK_FROM table TK_WHERE expr
 387         {
 388             SQL_input* sql = (SQL_input*) info;
 389             MSIVIEW *view = NULL;
 390             UINT r;
 391
 392             $$ = NULL;
 393             TRACE("From table: %s\n",debugstr_w($2));
 394             r = TABLE_CreateView( sql->db, $2, &view );
 395             if( r != ERROR_SUCCESS )
 396                 YYABORT;
 397             r = WHERE_CreateView( sql->db, &view, view, $4 );
 398             if( r != ERROR_SUCCESS )
 399                 YYABORT;
 400             $$ = view;
 401         }
 402     ;
 403
 404 expr:
 405     TK_LP expr TK_RP
 406         {
 407             $$ = $2;
 408         }
 409   | column_val TK_EQ column_val
 410         {
 411             $$ = EXPR_complex( $1, OP_EQ, $3 );
 412         }
 413   | expr TK_AND expr
 414         {
 415             $$ = EXPR_complex( $1, OP_AND, $3 );
 416         }
 417   | expr TK_OR expr
 418         {
 419             $$ = EXPR_complex( $1, OP_OR, $3 );
 420         }
 421   | column_val TK_EQ val
 422         {
 423             $$ = EXPR_complex( $1, OP_EQ, $3 );
 424         }
 425   | column_val TK_GT val
 426         {
 427             $$ = EXPR_complex( $1, OP_GT, $3 );
 428         }
 429   | column_val TK_LT val
 430         {
 431             $$ = EXPR_complex( $1, OP_LT, $3 );
 432         }
 433   | column_val TK_LE val
 434         {
 435             $$ = EXPR_complex( $1, OP_LE, $3 );
 436         }
 437   | column_val TK_GE val
 438         {
 439             $$ = EXPR_complex( $1, OP_GE, $3 );
 440         }
 441   | column_val TK_NE val
 442         {
 443             $$ = EXPR_complex( $1, OP_NE, $3 );
 444         }
 445   | column_val TK_IS TK_NULL
 446         {
 447             $$ = EXPR_complex( $1, OP_ISNULL, NULL );
 448         }
 449   | column_val TK_IS TK_NOT TK_NULL
 450         {
 451             $$ = EXPR_complex( $1, OP_NOTNULL, NULL );
 452         }
 453     ;
 454
 455 val:
 456     column_val
 457   | const_val
 458     ;
 459
 460 constlist:
 461     const_val
 462         {
 463             value_list *vals;
 464
 465             vals = HeapAlloc( GetProcessHeap(), 0, sizeof *vals );
 466             if( vals )
 467             {
 468                 vals->val = $1;
 469                 vals->next = NULL;
 470             }
 471             $$ = vals;
 472         }
 473   | constlist TK_COMMA const_val
 474         {
 475             value_list *vals;
 476
 477             vals = HeapAlloc( GetProcessHeap(), 0, sizeof *vals );
 478             if( vals )
 479             {
 480                 vals->val = $3;
 481                 vals->next = NULL;
 482             }
 483             $1->next = vals;
 484             $$ = $1;
 485         }
 486         ;
 487
 488 const_val:
 489     TK_INTEGER
 490         {
 491             $$ = EXPR_ival( &$1 );
 492         }
 493   | TK_STRING
 494         {
 495             $$ = EXPR_sval( &$1 );
 496         }
 497   | TK_WILDCARD
 498         {
 499             $$ = EXPR_wildcard();
 500         }
 501     ;
 502
 503 column_val:
 504     column
 505         {
 506             $$ = EXPR_column( $1 );
 507         }
 508     ;
 509
 510 column:
 511     table TK_DOT string_or_id
 512         {
 513             $$ = $3;  /* FIXME */
 514         }
 515   | string_or_id
 516         {
 517             $$ = $1;
 518         }
 519     ;
 520
 521 table:
 522     string_or_id
 523         {
 524             $$ = $1;
 525         }
 526     ;
 527
 528 string_or_id:
 529     TK_ID
 530         {
 531             $$ = SQL_getstring( &$1 );
 532         }
 533   | TK_STRING
 534         {
 535             $$ = SQL_getstring( &$1 );
 536         }
 537     ;
 538
 539 %%
 540
 541 int SQL_lex( void *SQL_lval, SQL_input *sql)
 542 {
 543     int token;
 544     struct sql_str * str = SQL_lval;
 545
 546     do
 547     {
 548         sql->n += sql->len;
 549         if( ! sql->command[sql->n] )
 550             return 0;  /* end of input */
 551
 552         TRACE("string : %s\n", debugstr_w(&sql->command[sql->n]));
 553         sql->len = sqliteGetToken( &sql->command[sql->n], &token );
 554         if( sql->len==0 )
 555             break;
 556         str->data = &sql->command[sql->n];
 557         str->len = sql->len;
 558     }
 559     while( token == TK_SPACE );
 560
 561     TRACE("token : %d (%s)\n", token, debugstr_wn(&sql->command[sql->n], sql->len));
 562
 563     return token;
 564 }
 565
 566 LPWSTR SQL_getstring( struct sql_str *strdata)
 567 {
 568     LPCWSTR p = strdata->data;
 569     UINT len = strdata->len;
 570     LPWSTR str;
 571
 572     /* if there's quotes, remove them */
 573     if( ( (p[0]=='`') && (p[len-1]=='`') ) ||
 574         ( (p[0]=='\'') && (p[len-1]=='\'') ) )
 575     {
 576         p++;
 577         len -= 2;
 578     }
 579     str = HeapAlloc( GetProcessHeap(), 0, (len + 1)*sizeof(WCHAR));
 580     if(!str )
 581         return str;
 582     memcpy(str, p, len*sizeof(WCHAR) );
 583     str[len]=0;
 584
 585     return str;
 586 }
 587
 588 INT SQL_getint( SQL_input *sql )
 589 {
 590     LPCWSTR p = &sql->command[sql->n];
 591
 592     return atoiW( p );
 593 }
 594
 595 int SQL_error(const char *str)
 596 {
 597     return 0;
 598 }
 599
 600 static MSIVIEW *do_one_select( MSIDATABASE *db, MSIVIEW *in,
 601                                string_list *columns )
 602 {
 603     MSIVIEW *view = NULL;
 604
 605     SELECT_CreateView( db, &view, in, columns );
 606     delete_string_list( columns );
 607     if( !view )
 608         ERR("Error creating select query\n");
 609     return view;
 610 }
 611
 612 static MSIVIEW *do_order_by( MSIDATABASE *db, MSIVIEW *in,
 613                              string_list *columns )
 614 {
 615     MSIVIEW *view = NULL;
 616
 617     ORDER_CreateView( db, &view, in );
 618     if( view )
 619     {
 620         string_list *x = columns;
 621
 622         for( x = columns; x ; x = x->next )
 623             ORDER_AddColumn( view, x->string );
 624     }
 625     else
 626         ERR("Error creating select query\n");
 627     delete_string_list( columns );
 628     return view;
 629 }
 630
 631 static struct expr * EXPR_wildcard()
 632 {
 633     struct expr *e = HeapAlloc( GetProcessHeap(), 0, sizeof *e );
 634     if( e )
 635     {
 636         e->type = EXPR_WILDCARD;
 637     }
 638     return e;
 639 }
 640
 641 static struct expr * EXPR_complex( struct expr *l, UINT op, struct expr *r )
 642 {
 643     struct expr *e = HeapAlloc( GetProcessHeap(), 0, sizeof *e );
 644     if( e )
 645     {
 646         e->type = EXPR_COMPLEX;
 647         e->u.expr.left = l;
 648         e->u.expr.op = op;
 649         e->u.expr.right = r;
 650     }
 651     return e;
 652 }
 653
 654 static struct expr * EXPR_column( LPWSTR str )
 655 {
 656     struct expr *e = HeapAlloc( GetProcessHeap(), 0, sizeof *e );
 657     if( e )
 658     {
 659         e->type = EXPR_COLUMN;
 660         e->u.sval = str;
 661     }
 662     return e;
 663 }
 664
 665 static struct expr * EXPR_ival( struct sql_str *str )
 666 {
 667     struct expr *e = HeapAlloc( GetProcessHeap(), 0, sizeof *e );
 668     if( e )
 669     {
 670         e->type = EXPR_IVAL;
 671         e->u.ival = atoiW( str->data );
 672     }
 673     return e;
 674 }
 675
 676 static struct expr * EXPR_sval( struct sql_str *str )
 677 {
 678     struct expr *e = HeapAlloc( GetProcessHeap(), 0, sizeof *e );
 679     if( e )
 680     {
 681         e->type = EXPR_SVAL;
 682         e->u.sval = SQL_getstring( str );
 683     }
 684     return e;
 685 }
 686
 687 void delete_expr( struct expr *e )
 688 {
 689     if( !e )
 690         return;
 691     if( e->type == EXPR_COMPLEX )
 692     {
 693         delete_expr( e->u.expr.left );
 694         delete_expr( e->u.expr.right );
 695     }
 696     else if( e->type == EXPR_UTF8 )
 697         HeapFree( GetProcessHeap(), 0, e->u.utf8 );
 698     else if( e->type == EXPR_SVAL )
 699         HeapFree( GetProcessHeap(), 0, e->u.sval );
 700     HeapFree( GetProcessHeap(), 0, e );
 701 }
 702
 703 void delete_string_list( string_list *sl )
 704 {
 705     while( sl )
 706     {
 707         string_list *t = sl->next;
 708         HeapFree( GetProcessHeap(), 0, sl->string );
 709         HeapFree( GetProcessHeap(), 0, sl );
 710         sl = t;
 711     }
 712 }
 713
 714 void delete_value_list( value_list *vl )
 715 {
 716     while( vl )
 717     {
 718         value_list *t = vl->next;
 719         delete_expr( vl->val );
 720         HeapFree( GetProcessHeap(), 0, vl );
 721         vl = t;
 722     }
 723 }
 724
 725 static BOOL SQL_MarkPrimaryKeys( create_col_info *cols,
 726                                  string_list *keys )
 727 {
 728     string_list *k;
 729     BOOL found = TRUE;
 730
 731     for( k = keys; k && found; k = k->next )
 732     {
 733         create_col_info *c;
 734
 735         found = FALSE;
 736         for( c = cols; c && !found; c = c->next )
 737         {
 738              if( lstrcmpW( k->string, c->colname ) )
 739                  continue;
 740              c->type |= MSITYPE_KEY;
 741              found = TRUE;
 742         }
 743     }
 744
 745     return found;
 746 }
 747
 748 UINT MSI_ParseSQL( MSIDATABASE *db, LPCWSTR command, MSIVIEW **phview )
 749 {
 750     SQL_input sql;
 751     int r;
 752
 753     *phview = NULL;
 754
 755     sql.db = db;
 756     sql.command = command;
 757     sql.n = 0;
 758     sql.len = 0;
 759     sql.view = phview;
 760
 761     r = SQL_parse(&sql);
 762
 763     TRACE("Parse returned %d\n", r);
 764     if( r )
 765     {
 766         if( *sql.view )
 767             (*sql.view)->ops->delete( *sql.view );
 768         *sql.view = NULL;
 769         return ERROR_BAD_QUERY_SYNTAX;
 770     }
 771
 772     return ERROR_SUCCESS;
 773 }