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