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