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 #include <stdarg.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "query.h"
  30 #include "wine/list.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(msi);
  34
  35 static UINT SQL_getstring( void *info, const struct sql_str *strdata, LPWSTR *str );
  36 static INT SQL_getint( void *info );
  37 static int sql_lex( void *SQL_lval, SQL_input *info );
  38 static int sql_error( SQL_input *info, const char *str);
  39
  40 static LPWSTR parser_add_table( void *info, LPCWSTR list, LPCWSTR table );
  41 static void *parser_alloc( void *info, unsigned int sz );
  42 static column_info *parser_alloc_column( void *info, LPCWSTR table, LPCWSTR column );
  43
  44 static BOOL SQL_MarkPrimaryKeys( column_info **cols, column_info *keys);
  45
  46 static struct expr * EXPR_complex( void *info, struct expr *l, UINT op, struct expr *r );
  47 static struct expr * EXPR_unary( void *info, struct expr *l, UINT op );
  48 static struct expr * EXPR_column( void *info, const column_info *column );
  49 static struct expr * EXPR_ival( void *info, int val );
  50 static struct expr * EXPR_sval( void *info, const struct sql_str *str );
  51 static struct expr * EXPR_wildcard( void *info );
  52
  53 #define PARSER_BUBBLE_UP_VIEW( sql, result, current_view ) \
  54     *sql->view = current_view; \
  55     result = current_view
  56
  57 %}
  58
  59 %lex-param { SQL_input *info }
  60 %parse-param { SQL_input *info }
  61 %define api.pure
  62
  63 %union
  64 {
  65     struct sql_str str;
  66     LPWSTR string;
  67     column_info *column_list;
  68     MSIVIEW *query;
  69     struct expr *expr;
  70     USHORT column_type;
  71     int integer;
  72 }
  73
  74 %token TK_ALTER TK_AND TK_BY TK_CHAR TK_COMMA TK_CREATE TK_DELETE TK_DROP
  75 %token TK_DISTINCT TK_DOT TK_EQ TK_FREE TK_FROM TK_GE TK_GT TK_HOLD TK_ADD
  76 %token <str> TK_ID
  77 %token TK_ILLEGAL TK_INSERT TK_INT
  78 %token <str> TK_INTEGER
  79 %token TK_INTO TK_IS TK_KEY TK_LE TK_LONG TK_LONGCHAR TK_LP TK_LT
  80 %token TK_LOCALIZABLE TK_MINUS TK_NE TK_NOT TK_NULL
  81 %token TK_OBJECT TK_OR TK_ORDER TK_PRIMARY TK_RP
  82 %token TK_SELECT TK_SET TK_SHORT TK_SPACE TK_STAR
  83 %token <str> TK_STRING
  84 %token TK_TABLE TK_TEMPORARY TK_UPDATE TK_VALUES TK_WHERE TK_WILDCARD
  85
  86 /*
  87  * These are extra tokens used by the lexer but never seen by the
  88  * parser.  We put them in a rule so that the parser generator will
  89  * add them to the parse.h output file.
  90  *
  91  */
  92 %nonassoc END_OF_FILE ILLEGAL SPACE UNCLOSED_STRING COMMENT FUNCTION
  93           COLUMN AGG_FUNCTION.
  94
  95 %type <string> table tablelist id string
  96 %type <column_list> selcollist collist selcolumn column column_and_type column_def table_def
  97 %type <column_list> column_assignment update_assign_list constlist
  98 %type <query> query from selectfrom unorderdfrom
  99 %type <query> oneupdate onedelete oneselect onequery onecreate oneinsert onealter onedrop
 100 %type <expr> expr val column_val const_val
 101 %type <column_type> column_type data_type data_type_l data_count
 102 %type <integer> number alterop
 103
 104 %left TK_OR
 105 %left TK_AND
 106 %left TK_NOT
 107 %left TK_EQ TK_NE TK_LT TK_GT TK_LE TK_GE TK_LIKE
 108 %right TK_NEGATION
 109
 110 %%
 111
 112 query:
 113     onequery
 114     {
 115         SQL_input* sql = (SQL_input*) info;
 116         *sql->view = $1;
 117     }
 118     ;
 119
 120 onequery:
 121     oneselect
 122   | onecreate
 123   | oneinsert
 124   | oneupdate
 125   | onedelete
 126   | onealter
 127   | onedrop
 128     ;
 129
 130 oneinsert:
 131     TK_INSERT TK_INTO table TK_LP collist TK_RP TK_VALUES TK_LP constlist TK_RP
 132         {
 133             SQL_input *sql = (SQL_input*) info;
 134             MSIVIEW *insert = NULL;
 135
 136             INSERT_CreateView( sql->db, &insert, $3, $5, $9, FALSE );
 137             if( !insert )
 138                 YYABORT;
 139
 140             PARSER_BUBBLE_UP_VIEW( sql, $$,  insert );
 141         }
 142   | TK_INSERT TK_INTO table TK_LP collist TK_RP TK_VALUES TK_LP constlist TK_RP TK_TEMPORARY
 143         {
 144             SQL_input *sql = (SQL_input*) info;
 145             MSIVIEW *insert = NULL;
 146
 147             INSERT_CreateView( sql->db, &insert, $3, $5, $9, TRUE );
 148             if( !insert )
 149                 YYABORT;
 150
 151             PARSER_BUBBLE_UP_VIEW( sql, $$,  insert );
 152         }
 153     ;
 154
 155 onecreate:
 156     TK_CREATE TK_TABLE table TK_LP table_def TK_RP
 157         {
 158             SQL_input* sql = (SQL_input*) info;
 159             MSIVIEW *create = NULL;
 160             UINT r;
 161
 162             if( !$5 )
 163                 YYABORT;
 164             r = CREATE_CreateView( sql->db, &create, $3, $5, FALSE );
 165             if( !create )
 166             {
 167                 sql->r = r;
 168                 YYABORT;
 169             }
 170
 171             PARSER_BUBBLE_UP_VIEW( sql, $$,  create );
 172         }
 173   | TK_CREATE TK_TABLE table TK_LP table_def TK_RP TK_HOLD
 174         {
 175             SQL_input* sql = (SQL_input*) info;
 176             MSIVIEW *create = NULL;
 177
 178             if( !$5 )
 179                 YYABORT;
 180             CREATE_CreateView( sql->db, &create, $3, $5, TRUE );
 181             if( !create )
 182                 YYABORT;
 183
 184             PARSER_BUBBLE_UP_VIEW( sql, $$,  create );
 185         }
 186     ;
 187
 188 oneupdate:
 189     TK_UPDATE table TK_SET update_assign_list TK_WHERE expr
 190         {
 191             SQL_input* sql = (SQL_input*) info;
 192             MSIVIEW *update = NULL;
 193
 194             UPDATE_CreateView( sql->db, &update, $2, $4, $6 );
 195             if( !update )
 196                 YYABORT;
 197
 198             PARSER_BUBBLE_UP_VIEW( sql, $$,  update );
 199         }
 200   | TK_UPDATE table TK_SET update_assign_list
 201         {
 202             SQL_input* sql = (SQL_input*) info;
 203             MSIVIEW *update = NULL;
 204
 205             UPDATE_CreateView( sql->db, &update, $2, $4, NULL );
 206             if( !update )
 207                 YYABORT;
 208
 209             PARSER_BUBBLE_UP_VIEW( sql, $$,  update );
 210         }
 211     ;
 212
 213 onedelete:
 214     TK_DELETE from
 215         {
 216             SQL_input* sql = (SQL_input*) info;
 217             MSIVIEW *delete = NULL;
 218
 219             DELETE_CreateView( sql->db, &delete, $2 );
 220             if( !delete )
 221                 YYABORT;
 222
 223             PARSER_BUBBLE_UP_VIEW( sql, $$, 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
 237             PARSER_BUBBLE_UP_VIEW( sql, $$, alter );
 238         }
 239   | TK_ALTER TK_TABLE table TK_ADD column_and_type
 240         {
 241             SQL_input *sql = (SQL_input *)info;
 242             MSIVIEW *alter = NULL;
 243
 244             ALTER_CreateView( sql->db, &alter, $3, $5, 0 );
 245             if (!alter)
 246                 YYABORT;
 247
 248             PARSER_BUBBLE_UP_VIEW( sql, $$, alter );
 249         }
 250   | TK_ALTER TK_TABLE table TK_ADD column_and_type TK_HOLD
 251         {
 252             SQL_input *sql = (SQL_input *)info;
 253             MSIVIEW *alter = NULL;
 254
 255             ALTER_CreateView( sql->db, &alter, $3, $5, 1 );
 256             if (!alter)
 257                 YYABORT;
 258
 259             PARSER_BUBBLE_UP_VIEW( sql, $$, alter );
 260         }
 261     ;
 262
 263 alterop:
 264     TK_HOLD
 265         {
 266             $$ = 1;
 267         }
 268   | TK_FREE
 269         {
 270             $$ = -1;
 271         }
 272   ;
 273
 274 onedrop:
 275     TK_DROP TK_TABLE table
 276         {
 277             SQL_input* sql = (SQL_input*) info;
 278             MSIVIEW* drop = NULL;
 279             UINT r;
 280
 281             r = DROP_CreateView( sql->db, &drop, $3 );
 282             if( r != ERROR_SUCCESS || !$$ )
 283                 YYABORT;
 284
 285             PARSER_BUBBLE_UP_VIEW( sql, $$, drop );
 286         }
 287   ;
 288
 289 table_def:
 290     column_def TK_PRIMARY TK_KEY collist
 291         {
 292             if( SQL_MarkPrimaryKeys( &$1, $4 ) )
 293                 $$ = $1;
 294             else
 295                 $$ = NULL;
 296         }
 297     ;
 298
 299 column_def:
 300     column_def TK_COMMA column_and_type
 301         {
 302             column_info *ci;
 303
 304             for( ci = $1; ci->next; ci = ci->next )
 305                 ;
 306
 307             ci->next = $3;
 308             $$ = $1;
 309         }
 310   | column_and_type
 311         {
 312             $$ = $1;
 313         }
 314     ;
 315
 316 column_and_type:
 317     column column_type
 318         {
 319             $$ = $1;
 320             $$->type = ($2 | MSITYPE_VALID);
 321         }
 322     ;
 323
 324 column_type:
 325     data_type_l
 326         {
 327             $$ = $1;
 328         }
 329   | data_type_l TK_LOCALIZABLE
 330         {
 331             $$ = $1 | MSITYPE_LOCALIZABLE;
 332         }
 333   | data_type_l TK_TEMPORARY
 334         {
 335             $$ = $1 | MSITYPE_TEMPORARY;
 336         }
 337     ;
 338
 339 data_type_l:
 340     data_type
 341         {
 342             $$ |= MSITYPE_NULLABLE;
 343         }
 344   | data_type TK_NOT TK_NULL
 345         {
 346             $$ = $1;
 347         }
 348     ;
 349
 350 data_type:
 351     TK_CHAR
 352         {
 353             $$ = MSITYPE_STRING | 0x400;
 354         }
 355   | TK_CHAR TK_LP data_count TK_RP
 356         {
 357             $$ = MSITYPE_STRING | 0x400 | $3;
 358         }
 359   | TK_LONGCHAR
 360         {
 361             $$ = MSITYPE_STRING | 0x400;
 362         }
 363   | TK_SHORT
 364         {
 365             $$ = 2 | 0x400;
 366         }
 367   | TK_INT
 368         {
 369             $$ = 2 | 0x400;
 370         }
 371   | TK_LONG
 372         {
 373             $$ = 4;
 374         }
 375   | TK_OBJECT
 376         {
 377             $$ = MSITYPE_STRING | MSITYPE_VALID;
 378         }
 379     ;
 380
 381 data_count:
 382     number
 383         {
 384             if( ( $1 > 255 ) || ( $1 < 0 ) )
 385                 YYABORT;
 386             $$ = $1;
 387         }
 388     ;
 389
 390 oneselect:
 391     TK_SELECT selectfrom
 392         {
 393             $$ = $2;
 394         }
 395   | TK_SELECT TK_DISTINCT selectfrom
 396         {
 397             SQL_input* sql = (SQL_input*) info;
 398             MSIVIEW* distinct = NULL;
 399             UINT r;
 400
 401             r = DISTINCT_CreateView( sql->db, &distinct, $3 );
 402             if (r != ERROR_SUCCESS)
 403                 YYABORT;
 404
 405             PARSER_BUBBLE_UP_VIEW( sql, $$, distinct );
 406         }
 407     ;
 408
 409 selectfrom:
 410     selcollist from
 411         {
 412             SQL_input* sql = (SQL_input*) info;
 413             MSIVIEW* select = NULL;
 414             UINT r;
 415
 416             if( $1 )
 417             {
 418                 r = SELECT_CreateView( sql->db, &select, $2, $1 );
 419                 if (r != ERROR_SUCCESS)
 420                     YYABORT;
 421
 422                 PARSER_BUBBLE_UP_VIEW( sql, $$, select );
 423             }
 424             else
 425                 $$ = $2;
 426         }
 427     ;
 428
 429 selcollist:
 430     selcolumn
 431   | selcolumn TK_COMMA selcollist
 432         {
 433             $1->next = $3;
 434         }
 435   | TK_STAR
 436         {
 437             $$ = NULL;
 438         }
 439     ;
 440
 441 collist:
 442     column
 443   | column TK_COMMA collist
 444         {
 445             $1->next = $3;
 446         }
 447   | TK_STAR
 448         {
 449             $$ = NULL;
 450         }
 451     ;
 452
 453 from:
 454     TK_FROM table
 455         {
 456             SQL_input* sql = (SQL_input*) info;
 457             MSIVIEW* table = NULL;
 458             UINT r;
 459
 460             r = TABLE_CreateView( sql->db, $2, &table );
 461             if( r != ERROR_SUCCESS || !$$ )
 462                 YYABORT;
 463
 464             PARSER_BUBBLE_UP_VIEW( sql, $$, table );
 465         }
 466   | unorderdfrom TK_ORDER TK_BY collist
 467         {
 468             UINT r;
 469
 470             if( $4 )
 471             {
 472                 r = $1->ops->sort( $1, $4 );
 473                 if ( r != ERROR_SUCCESS)
 474                     YYABORT;
 475             }
 476
 477             $$ = $1;
 478         }
 479   | unorderdfrom
 480   ;
 481
 482 unorderdfrom:
 483     TK_FROM tablelist
 484         {
 485             SQL_input* sql = (SQL_input*) info;
 486             MSIVIEW* where = NULL;
 487             UINT r;
 488
 489             r = WHERE_CreateView( sql->db, &where, $2, NULL );
 490             if( r != ERROR_SUCCESS )
 491                 YYABORT;
 492
 493             PARSER_BUBBLE_UP_VIEW( sql, $$, where );
 494         }
 495   | TK_FROM tablelist TK_WHERE expr
 496         {
 497             SQL_input* sql = (SQL_input*) info;
 498             MSIVIEW* where = NULL;
 499             UINT r;
 500
 501             r = WHERE_CreateView( sql->db, &where, $2, $4 );
 502             if( r != ERROR_SUCCESS )
 503                 YYABORT;
 504
 505             PARSER_BUBBLE_UP_VIEW( sql, $$, where );
 506         }
 507     ;
 508
 509 tablelist:
 510     table
 511         {
 512             $$ = $1;
 513         }
 514   | table TK_COMMA tablelist
 515         {
 516             $$ = parser_add_table( info, $3, $1 );
 517             if (!$$)
 518                 YYABORT;
 519         }
 520     ;
 521
 522 expr:
 523     TK_LP expr TK_RP
 524         {
 525             $$ = $2;
 526             if( !$$ )
 527                 YYABORT;
 528         }
 529   | expr TK_AND expr
 530         {
 531             $$ = EXPR_complex( info, $1, OP_AND, $3 );
 532             if( !$$ )
 533                 YYABORT;
 534         }
 535   | expr TK_OR expr
 536         {
 537             $$ = EXPR_complex( info, $1, OP_OR, $3 );
 538             if( !$$ )
 539                 YYABORT;
 540         }
 541   | column_val TK_EQ val
 542         {
 543             $$ = EXPR_complex( info, $1, OP_EQ, $3 );
 544             if( !$$ )
 545                 YYABORT;
 546         }
 547   | column_val TK_GT val
 548         {
 549             $$ = EXPR_complex( info, $1, OP_GT, $3 );
 550             if( !$$ )
 551                 YYABORT;
 552         }
 553   | column_val TK_LT val
 554         {
 555             $$ = EXPR_complex( info, $1, OP_LT, $3 );
 556             if( !$$ )
 557                 YYABORT;
 558         }
 559   | column_val TK_LE val
 560         {
 561             $$ = EXPR_complex( info, $1, OP_LE, $3 );
 562             if( !$$ )
 563                 YYABORT;
 564         }
 565   | column_val TK_GE val
 566         {
 567             $$ = EXPR_complex( info, $1, OP_GE, $3 );
 568             if( !$$ )
 569                 YYABORT;
 570         }
 571   | column_val TK_NE val
 572         {
 573             $$ = EXPR_complex( info, $1, OP_NE, $3 );
 574             if( !$$ )
 575                 YYABORT;
 576         }
 577   | column_val TK_IS TK_NULL
 578         {
 579             $$ = EXPR_unary( info, $1, OP_ISNULL );
 580             if( !$$ )
 581                 YYABORT;
 582         }
 583   | column_val TK_IS TK_NOT TK_NULL
 584         {
 585             $$ = EXPR_unary( info, $1, OP_NOTNULL );
 586             if( !$$ )
 587                 YYABORT;
 588         }
 589     ;
 590
 591 val:
 592     column_val
 593   | const_val
 594     ;
 595
 596 constlist:
 597     const_val
 598         {
 599             $$ = parser_alloc_column( info, NULL, NULL );
 600             if( !$$ )
 601                 YYABORT;
 602             $$->val = $1;
 603         }
 604   | const_val TK_COMMA constlist
 605         {
 606             $$ = parser_alloc_column( info, NULL, NULL );
 607             if( !$$ )
 608                 YYABORT;
 609             $$->val = $1;
 610             $$->next = $3;
 611         }
 612     ;
 613
 614 update_assign_list:
 615     column_assignment
 616   | column_assignment TK_COMMA update_assign_list
 617         {
 618             $$ = $1;
 619             $$->next = $3;
 620         }
 621     ;
 622
 623 column_assignment:
 624     column TK_EQ const_val
 625         {
 626             $$ = $1;
 627             $$->val = $3;
 628         }
 629     ;
 630
 631 const_val:
 632     number
 633         {
 634             $$ = EXPR_ival( info, $1 );
 635             if( !$$ )
 636                 YYABORT;
 637         }
 638   | TK_MINUS number %prec TK_NEGATION
 639         {
 640             $$ = EXPR_ival( info, -$2 );
 641             if( !$$ )
 642                 YYABORT;
 643         }
 644   | TK_STRING
 645         {
 646             $$ = EXPR_sval( info, &$1 );
 647             if( !$$ )
 648                 YYABORT;
 649         }
 650   | TK_WILDCARD
 651         {
 652             $$ = EXPR_wildcard( info );
 653             if( !$$ )
 654                 YYABORT;
 655         }
 656    | TK_NULL
 657         {
 658             $$ = EXPR_sval( info, NULL );
 659             if ( !$$ )
 660                 YYABORT;
 661         }
 662     ;
 663
 664 column_val:
 665     column
 666         {
 667             $$ = EXPR_column( info, $1 );
 668             if( !$$ )
 669                 YYABORT;
 670         }
 671     ;
 672
 673 column:
 674     table TK_DOT id
 675         {
 676             $$ = parser_alloc_column( info, $1, $3 );
 677             if( !$$ )
 678                 YYABORT;
 679         }
 680   | id
 681         {
 682             $$ = parser_alloc_column( info, NULL, $1 );
 683             if( !$$ )
 684                 YYABORT;
 685         }
 686     ;
 687
 688 selcolumn:
 689     table TK_DOT id
 690         {
 691             $$ = parser_alloc_column( info, $1, $3 );
 692             if( !$$ )
 693                 YYABORT;
 694         }
 695   | id
 696         {
 697             $$ = parser_alloc_column( info, NULL, $1 );
 698             if( !$$ )
 699                 YYABORT;
 700         }
 701   | string
 702         {
 703             $$ = parser_alloc_column( info, NULL, $1 );
 704             if( !$$ )
 705                 YYABORT;
 706         }
 707     ;
 708
 709 table:
 710     id
 711         {
 712             $$ = $1;
 713         }
 714     ;
 715
 716 id:
 717     TK_ID
 718         {
 719             if ( SQL_getstring( info, &$1, &$$ ) != ERROR_SUCCESS || !$$ )
 720                 YYABORT;
 721         }
 722     ;
 723
 724 string:
 725     TK_STRING
 726         {
 727             if ( SQL_getstring( info, &$1, &$$ ) != ERROR_SUCCESS || !$$ )
 728                 YYABORT;
 729         }
 730     ;
 731
 732 number:
 733     TK_INTEGER
 734         {
 735             $$ = SQL_getint( info );
 736         }
 737     ;
 738
 739 %%
 740
 741 static LPWSTR parser_add_table( void *info, LPCWSTR list, LPCWSTR table )
 742 {
 743     DWORD len = lstrlenW( list ) + lstrlenW( table ) + 2;
 744     LPWSTR ret;
 745
 746     ret = parser_alloc( info, len * sizeof(WCHAR) );
 747     if( ret )
 748     {
 749         lstrcpyW( ret, list );
 750         lstrcatW( ret, L" " );
 751         lstrcatW( 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( !str) e->u.sval = NULL;
 925         else if( SQL_getstring( info, str, (LPWSTR *)&e->u.sval ) != ERROR_SUCCESS )
 926             return NULL; /* e will be freed by query destructor */
 927     }
 928     return e;
 929 }
 930
 931 static void swap_columns( column_info **cols, column_info *A, int idx )
 932 {
 933     column_info *preA = NULL, *preB = NULL, *B, *ptr;
 934     int i = 0;
 935
 936     B = NULL;
 937     ptr = *cols;
 938     while( ptr )
 939     {
 940         if( i++ == idx )
 941             B = ptr;
 942         else if( !B )
 943             preB = ptr;
 944
 945         if( ptr->next == A )
 946             preA = ptr;
 947
 948         ptr = ptr->next;
 949     }
 950
 951     if( preB ) preB->next = A;
 952     if( preA ) preA->next = B;
 953     ptr = A->next;
 954     A->next = B->next;
 955     B->next = ptr;
 956     if( idx == 0 )
 957       *cols = A;
 958 }
 959
 960 static BOOL SQL_MarkPrimaryKeys( column_info **cols,
 961                                  column_info *keys )
 962 {
 963     column_info *k;
 964     BOOL found = TRUE;
 965     int count;
 966
 967     for( k = keys, count = 0; k && found; k = k->next, count++ )
 968     {
 969         column_info *c;
 970         int idx;
 971
 972         found = FALSE;
 973         for( c = *cols, idx = 0; c && !found; c = c->next, idx++ )
 974         {
 975             if( wcscmp( k->column, c->column ) )
 976                 continue;
 977             c->type |= MSITYPE_KEY;
 978             found = TRUE;
 979             if (idx != count)
 980                 swap_columns( cols, c, count );
 981         }
 982     }
 983
 984     return found;
 985 }
 986
 987 UINT MSI_ParseSQL( MSIDATABASE *db, LPCWSTR command, MSIVIEW **phview,
 988                    struct list *mem )
 989 {
 990     SQL_input sql;
 991     int r;
 992
 993     *phview = NULL;
 994
 995     sql.db = db;
 996     sql.command = command;
 997     sql.n = 0;
 998     sql.len = 0;
 999     sql.r = ERROR_BAD_QUERY_SYNTAX;
1000     sql.view = phview;
1001     sql.mem = mem;
1002
1003     r = sql_parse(&sql);
1004
1005     TRACE("Parse returned %d\n", r);
1006     if( r )
1007     {
1008         if (*sql.view)
1009         {
1010             (*sql.view)->ops->delete(*sql.view);
1011             *sql.view = NULL;
1012         }
1013         return sql.r;
1014     }
1015
1016     return ERROR_SUCCESS;
1017 }