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