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