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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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/list.h"
  34 #include "wine/debug.h"
  35
  36 #define YYLEX_PARAM info
  37 #define YYPARSE_PARAM info
  38
  39 static int sql_error(const char *str);
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  42
  43 #define MSITYPE_TEMPORARY 0x8000
  44
  45 typedef struct tag_SQL_input
  46 {
  47     MSIDATABASE *db;
  48     LPCWSTR command;
  49     DWORD n, len;
  50     MSIVIEW **view;  /* view structure for the resulting query */
  51     struct list *mem;
  52 } SQL_input;
  53
  54 static LPWSTR SQL_getstring( void *info, const struct sql_str *str );
  55 static INT SQL_getint( void *info );
  56 static int sql_lex( void *SQL_lval, SQL_input *info );
  57
  58 static void *parser_alloc( void *info, unsigned int sz );
  59 static column_info *parser_alloc_column( void *info, LPCWSTR table, LPCWSTR column );
  60
  61 static BOOL SQL_MarkPrimaryKeys( column_info *cols, column_info *keys);
  62
  63 static struct expr * EXPR_complex( void *info, struct expr *l, UINT op, struct expr *r );
  64 static struct expr * EXPR_unary( void *info, struct expr *l, UINT op );
  65 static struct expr * EXPR_column( void *info, const column_info *column );
  66 static struct expr * EXPR_ival( void *info, int val );
  67 static struct expr * EXPR_sval( void *info, const struct sql_str * );
  68 static struct expr * EXPR_wildcard( void *info );
  69
  70 %}
  71
  72 %pure-parser
  73
  74 %union
  75 {
  76     struct sql_str str;
  77     LPWSTR string;
  78     column_info *column_list;
  79     MSIVIEW *query;
  80     struct expr *expr;
  81     USHORT column_type;
  82     int integer;
  83 }
  84
  85 %token TK_ALTER TK_AND TK_BY TK_CHAR TK_COMMA TK_CREATE TK_DELETE
  86 %token TK_DISTINCT TK_DOT TK_EQ TK_FREE TK_FROM TK_GE TK_GT TK_HOLD
  87 %token <str> TK_ID
  88 %token TK_ILLEGAL TK_INSERT TK_INT
  89 %token <str> TK_INTEGER
  90 %token TK_INTO TK_IS TK_KEY TK_LE TK_LONG TK_LONGCHAR TK_LP TK_LT
  91 %token TK_LOCALIZABLE TK_MINUS TK_NE TK_NOT TK_NULL
  92 %token TK_OBJECT TK_OR TK_ORDER TK_PRIMARY TK_RP
  93 %token TK_SELECT TK_SET TK_SHORT TK_SPACE TK_STAR
  94 %token <str> TK_STRING
  95 %token TK_TABLE TK_TEMPORARY TK_UPDATE TK_VALUES TK_WHERE TK_WILDCARD
  96
  97 /*
  98  * These are extra tokens used by the lexer but never seen by the
  99  * parser.  We put them in a rule so that the parser generator will
 100  * add them to the parse.h output file.
 101  *
 102  */
 103 %nonassoc END_OF_FILE ILLEGAL SPACE UNCLOSED_STRING COMMENT FUNCTION
 104           COLUMN AGG_FUNCTION.
 105
 106 %type <string> table id
 107 %type <column_list> selcollist column column_and_type column_def table_def
 108 %type <column_list> column_assignment update_assign_list constlist
 109 %type <query> query from fromtable selectfrom unorderedsel
 110 %type <query> oneupdate onedelete oneselect onequery onecreate oneinsert onealter
 111 %type <expr> expr val column_val const_val
 112 %type <column_type> column_type data_type data_type_l data_count
 113 %type <integer> number alterop
 114
 115 /* Reference: http://mates.ms.mff.cuni.cz/oracle/doc/ora815nt/server.815/a67779/operator.htm */
 116 %left TK_OR
 117 %left TK_AND
 118 %left TK_NOT
 119 %left TK_EQ TK_NE TK_LT TK_GT TK_LE TK_GE TK_LIKE
 120 %right TK_NEGATION
 121
 122 %%
 123
 124 query:
 125     onequery
 126     {
 127         SQL_input* sql = (SQL_input*) info;
 128         *sql->view = $1;
 129     }
 130     ;
 131
 132 onequery:
 133     oneselect
 134   | onecreate
 135   | oneinsert
 136   | oneupdate
 137   | onedelete
 138   | onealter
 139     ;
 140
 141 oneinsert:
 142     TK_INSERT TK_INTO table TK_LP selcollist TK_RP TK_VALUES TK_LP constlist TK_RP
 143         {
 144             SQL_input *sql = (SQL_input*) info;
 145             MSIVIEW *insert = NULL;
 146             UINT r;
 147
 148             r = INSERT_CreateView( sql->db, &insert, $3, $5, $9, FALSE );
 149             if( !insert )
 150                 YYABORT;
 151             $$ = insert;
 152         }
 153   | TK_INSERT TK_INTO table TK_LP selcollist TK_RP TK_VALUES TK_LP constlist TK_RP TK_TEMPORARY
 154         {
 155             SQL_input *sql = (SQL_input*) info;
 156             MSIVIEW *insert = NULL;
 157
 158             INSERT_CreateView( sql->db, &insert, $3, $5, $9, TRUE );
 159             if( !insert )
 160                 YYABORT;
 161             $$ = insert;
 162         }
 163     ;
 164
 165 onecreate:
 166     TK_CREATE TK_TABLE table TK_LP table_def TK_RP
 167         {
 168             SQL_input* sql = (SQL_input*) info;
 169             MSIVIEW *create = NULL;
 170
 171             if( !$5 )
 172                 YYABORT;
 173             CREATE_CreateView( sql->db, &create, $3, $5, FALSE );
 174             if( !create )
 175                 YYABORT;
 176             $$ = create;
 177         }
 178   | TK_CREATE TK_TABLE table TK_LP table_def TK_RP TK_HOLD
 179         {
 180             SQL_input* sql = (SQL_input*) info;
 181             MSIVIEW *create = NULL;
 182
 183             if( !$5 )
 184                 YYABORT;
 185             CREATE_CreateView( sql->db, &create, $3, $5, TRUE );
 186             if( !create )
 187                 YYABORT;
 188             $$ = create;
 189         }
 190     ;
 191
 192 oneupdate:
 193     TK_UPDATE table TK_SET update_assign_list TK_WHERE expr
 194         {
 195             SQL_input* sql = (SQL_input*) info;
 196             MSIVIEW *update = NULL;
 197
 198             UPDATE_CreateView( sql->db, &update, $2, $4, $6 );
 199             if( !update )
 200                 YYABORT;
 201             $$ = update;
 202         }
 203   | TK_UPDATE table TK_SET update_assign_list
 204         {
 205             SQL_input* sql = (SQL_input*) info;
 206             MSIVIEW *update = NULL;
 207
 208             UPDATE_CreateView( sql->db, &update, $2, $4, NULL );
 209             if( !update )
 210                 YYABORT;
 211             $$ = update;
 212         }
 213     ;
 214
 215 onedelete:
 216     TK_DELETE from
 217         {
 218             SQL_input* sql = (SQL_input*) info;
 219             MSIVIEW *delete = NULL;
 220
 221             DELETE_CreateView( sql->db, &delete, $2 );
 222             if( !delete )
 223                 YYABORT;
 224             $$ = delete;
 225         }
 226     ;
 227
 228 onealter:
 229     TK_ALTER TK_TABLE table alterop
 230         {
 231             SQL_input* sql = (SQL_input*) info;
 232             MSIVIEW *alter = NULL;
 233
 234             ALTER_CreateView( sql->db, &alter, $3, $4 );
 235             if( !alter )
 236                 YYABORT;
 237             $$ = alter;
 238         }
 239     ;
 240
 241 alterop:
 242     TK_HOLD
 243         {
 244             $$ = 1;
 245         }
 246   | TK_FREE
 247         {
 248             $$ = -1;
 249         }
 250   ;
 251
 252 table_def:
 253     column_def TK_PRIMARY TK_KEY selcollist
 254         {
 255             if( SQL_MarkPrimaryKeys( $1, $4 ) )
 256                 $$ = $1;
 257             else
 258                 $$ = NULL;
 259         }
 260     ;
 261
 262 column_def:
 263     column_def TK_COMMA column_and_type
 264         {
 265             column_info *ci;
 266
 267             for( ci = $1; ci->next; ci = ci->next )
 268                 ;
 269
 270             ci->next = $3;
 271             $$ = $1;
 272         }
 273   | column_and_type
 274         {
 275             $$ = $1;
 276         }
 277     ;
 278
 279 column_and_type:
 280     column column_type
 281         {
 282             $$ = $1;
 283             $$->type = ($2 | MSITYPE_VALID) & ~MSITYPE_TEMPORARY;
 284             $$->temporary = $2 & MSITYPE_TEMPORARY ? TRUE : FALSE;
 285         }
 286     ;
 287
 288 column_type:
 289     data_type_l
 290         {
 291             $$ = $1;
 292         }
 293   | data_type_l TK_LOCALIZABLE
 294         {
 295             $$ = $1 | MSITYPE_LOCALIZABLE;
 296         }
 297   | data_type_l TK_TEMPORARY
 298         {
 299             $$ = $1 | MSITYPE_TEMPORARY;
 300         }
 301     ;
 302
 303 data_type_l:
 304     data_type
 305         {
 306             $$ |= MSITYPE_NULLABLE;
 307         }
 308   | data_type TK_NOT TK_NULL
 309         {
 310             $$ = $1;
 311         }
 312     ;
 313
 314 data_type:
 315     TK_CHAR
 316         {
 317             $$ = MSITYPE_STRING | 1;
 318         }
 319   | TK_CHAR TK_LP data_count TK_RP
 320         {
 321             $$ = MSITYPE_STRING | 0x400 | $3;
 322         }
 323   | TK_LONGCHAR
 324         {
 325             $$ = 2;
 326         }
 327   | TK_SHORT
 328         {
 329             $$ = 2;
 330         }
 331   | TK_INT
 332         {
 333             $$ = 2;
 334         }
 335   | TK_LONG
 336         {
 337             $$ = 4;
 338         }
 339   | TK_OBJECT
 340         {
 341             $$ = MSITYPE_STRING | MSITYPE_VALID;
 342         }
 343     ;
 344
 345 data_count:
 346     number
 347         {
 348             if( ( $1 > 255 ) || ( $1 < 0 ) )
 349                 YYABORT;
 350             $$ = $1;
 351         }
 352     ;
 353
 354 oneselect:
 355     unorderedsel TK_ORDER TK_BY selcollist
 356         {
 357             SQL_input* sql = (SQL_input*) info;
 358
 359             $$ = NULL;
 360             if( $4 )
 361                 ORDER_CreateView( sql->db, &$$, $1, $4 );
 362             else
 363                 $$ = $1;
 364             if( !$$ )
 365                 YYABORT;
 366         }
 367   | unorderedsel
 368     ;
 369
 370 unorderedsel:
 371     TK_SELECT selectfrom
 372         {
 373             $$ = $2;
 374         }
 375   | TK_SELECT TK_DISTINCT selectfrom
 376         {
 377             SQL_input* sql = (SQL_input*) info;
 378             UINT r;
 379
 380             $$ = NULL;
 381             r = DISTINCT_CreateView( sql->db, &$$, $3 );
 382             if (r != ERROR_SUCCESS)
 383             {
 384                 $3->ops->delete($3);
 385                 YYABORT;
 386             }
 387         }
 388     ;
 389
 390 selectfrom:
 391     selcollist from
 392         {
 393             SQL_input* sql = (SQL_input*) info;
 394             UINT r;
 395
 396             $$ = NULL;
 397             if( $1 )
 398             {
 399                 r = SELECT_CreateView( sql->db, &$$, $2, $1 );
 400                 if (r != ERROR_SUCCESS)
 401                 {
 402                     $2->ops->delete($2);
 403                     YYABORT;
 404                 }
 405             }
 406             else
 407                 $$ = $2;
 408         }
 409     ;
 410
 411 selcollist:
 412     column
 413   | column TK_COMMA selcollist
 414         {
 415             $1->next = $3;
 416         }
 417   | TK_STAR
 418         {
 419             $$ = NULL;
 420         }
 421     ;
 422
 423 from:
 424     fromtable
 425   | fromtable TK_WHERE expr
 426         {
 427             SQL_input* sql = (SQL_input*) info;
 428             UINT r;
 429
 430             $$ = NULL;
 431             r = WHERE_CreateView( sql->db, &$$, $1, $3 );
 432             if( r != ERROR_SUCCESS )
 433             {
 434                 $1->ops->delete( $1 );
 435                 YYABORT;
 436             }
 437         }
 438     ;
 439
 440 fromtable:
 441     TK_FROM table
 442         {
 443             SQL_input* sql = (SQL_input*) info;
 444             UINT r;
 445
 446             $$ = NULL;
 447             r = TABLE_CreateView( sql->db, $2, &$$ );
 448             if( r != ERROR_SUCCESS || !$$ )
 449                 YYABORT;
 450         }
 451   | TK_FROM table TK_COMMA table
 452         {
 453             SQL_input* sql = (SQL_input*) info;
 454             UINT r;
 455
 456             /* only support inner joins on two tables */
 457             r = JOIN_CreateView( sql->db, &$$, $2, $4 );
 458             if( r != ERROR_SUCCESS )
 459                 YYABORT;
 460         }
 461     ;
 462
 463 expr:
 464     TK_LP expr TK_RP
 465         {
 466             $$ = $2;
 467             if( !$$ )
 468                 YYABORT;
 469         }
 470   | expr TK_AND expr
 471         {
 472             $$ = EXPR_complex( info, $1, OP_AND, $3 );
 473             if( !$$ )
 474                 YYABORT;
 475         }
 476   | expr TK_OR expr
 477         {
 478             $$ = EXPR_complex( info, $1, OP_OR, $3 );
 479             if( !$$ )
 480                 YYABORT;
 481         }
 482   | column_val TK_EQ val
 483         {
 484             $$ = EXPR_complex( info, $1, OP_EQ, $3 );
 485             if( !$$ )
 486                 YYABORT;
 487         }
 488   | column_val TK_GT val
 489         {
 490             $$ = EXPR_complex( info, $1, OP_GT, $3 );
 491             if( !$$ )
 492                 YYABORT;
 493         }
 494   | column_val TK_LT val
 495         {
 496             $$ = EXPR_complex( info, $1, OP_LT, $3 );
 497             if( !$$ )
 498                 YYABORT;
 499         }
 500   | column_val TK_LE val
 501         {
 502             $$ = EXPR_complex( info, $1, OP_LE, $3 );
 503             if( !$$ )
 504                 YYABORT;
 505         }
 506   | column_val TK_GE val
 507         {
 508             $$ = EXPR_complex( info, $1, OP_GE, $3 );
 509             if( !$$ )
 510                 YYABORT;
 511         }
 512   | column_val TK_NE val
 513         {
 514             $$ = EXPR_complex( info, $1, OP_NE, $3 );
 515             if( !$$ )
 516                 YYABORT;
 517         }
 518   | column_val TK_IS TK_NULL
 519         {
 520             $$ = EXPR_unary( info, $1, OP_ISNULL );
 521             if( !$$ )
 522                 YYABORT;
 523         }
 524   | column_val TK_IS TK_NOT TK_NULL
 525         {
 526             $$ = EXPR_unary( info, $1, OP_NOTNULL );
 527             if( !$$ )
 528                 YYABORT;
 529         }
 530     ;
 531
 532 val:
 533     column_val
 534   | const_val
 535     ;
 536
 537 constlist:
 538     const_val
 539         {
 540             $$ = parser_alloc_column( info, NULL, NULL );
 541             if( !$$ )
 542                 YYABORT;
 543             $$->val = $1;
 544         }
 545   | const_val TK_COMMA constlist
 546         {
 547             $$ = parser_alloc_column( info, NULL, NULL );
 548             if( !$$ )
 549                 YYABORT;
 550             $$->val = $1;
 551             $$->next = $3;
 552         }
 553     ;
 554
 555 update_assign_list:
 556     column_assignment
 557   | column_assignment TK_COMMA update_assign_list
 558         {
 559             $$ = $1;
 560             $$->next = $3;
 561         }
 562     ;
 563
 564 column_assignment:
 565     column TK_EQ const_val
 566         {
 567             $$ = $1;
 568             $$->val = $3;
 569         }
 570     ;
 571
 572 const_val:
 573     number
 574         {
 575             $$ = EXPR_ival( info, $1 );
 576             if( !$$ )
 577                 YYABORT;
 578         }
 579   | TK_MINUS number %prec TK_NEGATION
 580         {
 581             $$ = EXPR_ival( info, -$2 );
 582             if( !$$ )
 583                 YYABORT;
 584         }
 585   | TK_STRING
 586         {
 587             $$ = EXPR_sval( info, &$1 );
 588             if( !$$ )
 589                 YYABORT;
 590         }
 591   | TK_WILDCARD
 592         {
 593             $$ = EXPR_wildcard( info );
 594             if( !$$ )
 595                 YYABORT;
 596         }
 597     ;
 598
 599 column_val:
 600     column
 601         {
 602             $$ = EXPR_column( info, $1 );
 603             if( !$$ )
 604                 YYABORT;
 605         }
 606     ;
 607
 608 column:
 609     table TK_DOT id
 610         {
 611             $$ = parser_alloc_column( info, $1, $3 );
 612             if( !$$ )
 613                 YYABORT;
 614         }
 615   | id
 616         {
 617             $$ = parser_alloc_column( info, NULL, $1 );
 618             if( !$$ )
 619                 YYABORT;
 620         }
 621     ;
 622
 623 table:
 624     id
 625         {
 626             $$ = $1;
 627         }
 628     ;
 629
 630 id:
 631     TK_ID
 632         {
 633             $$ = SQL_getstring( info, &$1 );
 634             if( !$$ )
 635                 YYABORT;
 636         }
 637     ;
 638
 639 number:
 640     TK_INTEGER
 641         {
 642             $$ = SQL_getint( info );
 643         }
 644     ;
 645
 646 %%
 647
 648 static void *parser_alloc( void *info, unsigned int sz )
 649 {
 650     SQL_input* sql = (SQL_input*) info;
 651     struct list *mem;
 652
 653     mem = msi_alloc( sizeof (struct list) + sz );
 654     list_add_tail( sql->mem, mem );
 655     return &mem[1];
 656 }
 657
 658 static column_info *parser_alloc_column( void *info, LPCWSTR table, LPCWSTR column )
 659 {
 660     column_info *col;
 661
 662     col = parser_alloc( info, sizeof (*col) );
 663     if( col )
 664     {
 665         col->table = table;
 666         col->column = column;
 667         col->val = NULL;
 668         col->type = 0;
 669         col->next = NULL;
 670     }
 671
 672     return col;
 673 }
 674
 675 static int sql_lex( void *SQL_lval, SQL_input *sql )
 676 {
 677     int token;
 678     struct sql_str * str = SQL_lval;
 679
 680     do
 681     {
 682         sql->n += sql->len;
 683         if( ! sql->command[sql->n] )
 684             return 0;  /* end of input */
 685
 686         /* TRACE("string : %s\n", debugstr_w(&sql->command[sql->n])); */
 687         sql->len = sqliteGetToken( &sql->command[sql->n], &token );
 688         if( sql->len==0 )
 689             break;
 690         str->data = &sql->command[sql->n];
 691         str->len = sql->len;
 692     }
 693     while( token == TK_SPACE );
 694
 695     /* TRACE("token : %d (%s)\n", token, debugstr_wn(&sql->command[sql->n], sql->len)); */
 696
 697     return token;
 698 }
 699
 700 LPWSTR SQL_getstring( void *info, const struct sql_str *strdata )
 701 {
 702     LPCWSTR p = strdata->data;
 703     UINT len = strdata->len;
 704     LPWSTR str;
 705
 706     /* if there's quotes, remove them */
 707     if( ( (p[0]=='`') && (p[len-1]=='`') ) ||
 708         ( (p[0]=='\'') && (p[len-1]=='\'') ) )
 709     {
 710         p++;
 711         len -= 2;
 712     }
 713     str = parser_alloc( info, (len + 1)*sizeof(WCHAR) );
 714     if( !str )
 715         return str;
 716     memcpy( str, p, len*sizeof(WCHAR) );
 717     str[len]=0;
 718
 719     return str;
 720 }
 721
 722 INT SQL_getint( void *info )
 723 {
 724     SQL_input* sql = (SQL_input*) info;
 725     LPCWSTR p = &sql->command[sql->n];
 726     INT i, r = 0;
 727
 728     for( i=0; i<sql->len; i++ )
 729     {
 730         if( '0' > p[i] || '9' < p[i] )
 731         {
 732             ERR("should only be numbers here!\n");
 733             break;
 734         }
 735         r = (p[i]-'0') + r*10;
 736     }
 737
 738     return r;
 739 }
 740
 741 static int sql_error( const char *str )
 742 {
 743     return 0;
 744 }
 745
 746 static struct expr * EXPR_wildcard( void *info )
 747 {
 748     struct expr *e = parser_alloc( info, sizeof *e );
 749     if( e )
 750     {
 751         e->type = EXPR_WILDCARD;
 752     }
 753     return e;
 754 }
 755
 756 static struct expr * EXPR_complex( void *info, struct expr *l, UINT op, struct expr *r )
 757 {
 758     struct expr *e = parser_alloc( info, sizeof *e );
 759     if( e )
 760     {
 761         e->type = EXPR_COMPLEX;
 762         e->u.expr.left = l;
 763         e->u.expr.op = op;
 764         e->u.expr.right = r;
 765     }
 766     return e;
 767 }
 768
 769 static struct expr * EXPR_unary( void *info, struct expr *l, UINT op )
 770 {
 771     struct expr *e = parser_alloc( info, sizeof *e );
 772     if( e )
 773     {
 774         e->type = EXPR_UNARY;
 775         e->u.expr.left = l;
 776         e->u.expr.op = op;
 777         e->u.expr.right = NULL;
 778     }
 779     return e;
 780 }
 781
 782 static struct expr * EXPR_column( void *info, const column_info *column )
 783 {
 784     struct expr *e = parser_alloc( info, sizeof *e );
 785     if( e )
 786     {
 787         e->type = EXPR_COLUMN;
 788         e->u.sval = column->column;
 789     }
 790     return e;
 791 }
 792
 793 static struct expr * EXPR_ival( void *info, int val )
 794 {
 795     struct expr *e = parser_alloc( info, sizeof *e );
 796     if( e )
 797     {
 798         e->type = EXPR_IVAL;
 799         e->u.ival = val;
 800     }
 801     return e;
 802 }
 803
 804 static struct expr * EXPR_sval( void *info, const struct sql_str *str )
 805 {
 806     struct expr *e = parser_alloc( info, sizeof *e );
 807     if( e )
 808     {
 809         e->type = EXPR_SVAL;
 810         e->u.sval = SQL_getstring( info, str );
 811     }
 812     return e;
 813 }
 814
 815 static BOOL SQL_MarkPrimaryKeys( column_info *cols,
 816                                  column_info *keys )
 817 {
 818     column_info *k;
 819     BOOL found = TRUE;
 820
 821     for( k = keys; k && found; k = k->next )
 822     {
 823         column_info *c;
 824
 825         found = FALSE;
 826         for( c = cols; c && !found; c = c->next )
 827         {
 828              if( lstrcmpW( k->column, c->column ) )
 829                  continue;
 830              c->type |= MSITYPE_KEY;
 831              found = TRUE;
 832         }
 833     }
 834
 835     return found;
 836 }
 837
 838 UINT MSI_ParseSQL( MSIDATABASE *db, LPCWSTR command, MSIVIEW **phview,
 839                    struct list *mem )
 840 {
 841     SQL_input sql;
 842     int r;
 843
 844     *phview = NULL;
 845
 846     sql.db = db;
 847     sql.command = command;
 848     sql.n = 0;
 849     sql.len = 0;
 850     sql.view = phview;
 851     sql.mem = mem;
 852
 853     r = sql_parse(&sql);
 854
 855     TRACE("Parse returned %d\n", r);
 856     if( r )
 857     {
 858         *sql.view = NULL;
 859         return ERROR_BAD_QUERY_SYNTAX;
 860     }
 861
 862     return ERROR_SUCCESS;
 863 }