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             $$->temporary = $2 & MSITYPE_TEMPORARY ? TRUE : FALSE;
 322         }
 323     ;
 324
 325 column_type:
 326     data_type_l
 327         {
 328             $$ = $1;
 329         }
 330   | data_type_l TK_LOCALIZABLE
 331         {
 332             $$ = $1 | MSITYPE_LOCALIZABLE;
 333         }
 334   | data_type_l TK_TEMPORARY
 335         {
 336             $$ = $1 | MSITYPE_TEMPORARY;
 337         }
 338     ;
 339
 340 data_type_l:
 341     data_type
 342         {
 343             $$ |= MSITYPE_NULLABLE;
 344         }
 345   | data_type TK_NOT TK_NULL
 346         {
 347             $$ = $1;
 348         }
 349     ;
 350
 351 data_type:
 352     TK_CHAR
 353         {
 354             $$ = MSITYPE_STRING | 0x400;
 355         }
 356   | TK_CHAR TK_LP data_count TK_RP
 357         {
 358             $$ = MSITYPE_STRING | 0x400 | $3;
 359         }
 360   | TK_LONGCHAR
 361         {
 362             $$ = MSITYPE_STRING | 0x400;
 363         }
 364   | TK_SHORT
 365         {
 366             $$ = 2 | 0x400;
 367         }
 368   | TK_INT
 369         {
 370             $$ = 2 | 0x400;
 371         }
 372   | TK_LONG
 373         {
 374             $$ = 4;
 375         }
 376   | TK_OBJECT
 377         {
 378             $$ = MSITYPE_STRING | MSITYPE_VALID;
 379         }
 380     ;
 381
 382 data_count:
 383     number
 384         {
 385             if( ( $1 > 255 ) || ( $1 < 0 ) )
 386                 YYABORT;
 387             $$ = $1;
 388         }
 389     ;
 390
 391 oneselect:
 392     TK_SELECT selectfrom
 393         {
 394             $$ = $2;
 395         }
 396   | TK_SELECT TK_DISTINCT selectfrom
 397         {
 398             SQL_input* sql = (SQL_input*) info;
 399             MSIVIEW* distinct = NULL;
 400             UINT r;
 401
 402             r = DISTINCT_CreateView( sql->db, &distinct, $3 );
 403             if (r != ERROR_SUCCESS)
 404                 YYABORT;
 405
 406             PARSER_BUBBLE_UP_VIEW( sql, $$, distinct );
 407         }
 408     ;
 409
 410 selectfrom:
 411     selcollist from
 412         {
 413             SQL_input* sql = (SQL_input*) info;
 414             MSIVIEW* select = NULL;
 415             UINT r;
 416
 417             if( $1 )
 418             {
 419                 r = SELECT_CreateView( sql->db, &select, $2, $1 );
 420                 if (r != ERROR_SUCCESS)
 421                     YYABORT;
 422
 423                 PARSER_BUBBLE_UP_VIEW( sql, $$, select );
 424             }
 425             else
 426                 $$ = $2;
 427         }
 428     ;
 429
 430 selcollist:
 431     selcolumn
 432   | selcolumn TK_COMMA selcollist
 433         {
 434             $1->next = $3;
 435         }
 436   | TK_STAR
 437         {
 438             $$ = NULL;
 439         }
 440     ;
 441
 442 collist:
 443     column
 444   | column TK_COMMA collist
 445         {
 446             $1->next = $3;
 447         }
 448   | TK_STAR
 449         {
 450             $$ = NULL;
 451         }
 452     ;
 453
 454 from:
 455     TK_FROM table
 456         {
 457             SQL_input* sql = (SQL_input*) info;
 458             MSIVIEW* table = NULL;
 459             UINT r;
 460
 461             r = TABLE_CreateView( sql->db, $2, &table );
 462             if( r != ERROR_SUCCESS || !$$ )
 463                 YYABORT;
 464
 465             PARSER_BUBBLE_UP_VIEW( sql, $$, table );
 466         }
 467   | unorderdfrom TK_ORDER TK_BY collist
 468         {
 469             UINT r;
 470
 471             if( $4 )
 472             {
 473                 r = $1->ops->sort( $1, $4 );
 474                 if ( r != ERROR_SUCCESS)
 475                     YYABORT;
 476             }
 477
 478             $$ = $1;
 479         }
 480   | unorderdfrom
 481   ;
 482
 483 unorderdfrom:
 484     TK_FROM tablelist
 485         {
 486             SQL_input* sql = (SQL_input*) info;
 487             MSIVIEW* where = NULL;
 488             UINT r;
 489
 490             r = WHERE_CreateView( sql->db, &where, $2, NULL );
 491             if( r != ERROR_SUCCESS )
 492                 YYABORT;
 493
 494             PARSER_BUBBLE_UP_VIEW( sql, $$, where );
 495         }
 496   | TK_FROM tablelist TK_WHERE expr
 497         {
 498             SQL_input* sql = (SQL_input*) info;
 499             MSIVIEW* where = NULL;
 500             UINT r;
 501
 502             r = WHERE_CreateView( sql->db, &where, $2, $4 );
 503             if( r != ERROR_SUCCESS )
 504                 YYABORT;
 505
 506             PARSER_BUBBLE_UP_VIEW( sql, $$, where );
 507         }
 508     ;
 509
 510 tablelist:
 511     table
 512         {
 513             $$ = $1;
 514         }
 515   | table TK_COMMA tablelist
 516         {
 517             $$ = parser_add_table( info, $3, $1 );
 518             if (!$$)
 519                 YYABORT;
 520         }
 521     ;
 522
 523 expr:
 524     TK_LP expr TK_RP
 525         {
 526             $$ = $2;
 527             if( !$$ )
 528                 YYABORT;
 529         }
 530   | expr TK_AND expr
 531         {
 532             $$ = EXPR_complex( info, $1, OP_AND, $3 );
 533             if( !$$ )
 534                 YYABORT;
 535         }
 536   | expr TK_OR expr
 537         {
 538             $$ = EXPR_complex( info, $1, OP_OR, $3 );
 539             if( !$$ )
 540                 YYABORT;
 541         }
 542   | column_val TK_EQ val
 543         {
 544             $$ = EXPR_complex( info, $1, OP_EQ, $3 );
 545             if( !$$ )
 546                 YYABORT;
 547         }
 548   | column_val TK_GT val
 549         {
 550             $$ = EXPR_complex( info, $1, OP_GT, $3 );
 551             if( !$$ )
 552                 YYABORT;
 553         }
 554   | column_val TK_LT val
 555         {
 556             $$ = EXPR_complex( info, $1, OP_LT, $3 );
 557             if( !$$ )
 558                 YYABORT;
 559         }
 560   | column_val TK_LE val
 561         {
 562             $$ = EXPR_complex( info, $1, OP_LE, $3 );
 563             if( !$$ )
 564                 YYABORT;
 565         }
 566   | column_val TK_GE val
 567         {
 568             $$ = EXPR_complex( info, $1, OP_GE, $3 );
 569             if( !$$ )
 570                 YYABORT;
 571         }
 572   | column_val TK_NE val
 573         {
 574             $$ = EXPR_complex( info, $1, OP_NE, $3 );
 575             if( !$$ )
 576                 YYABORT;
 577         }
 578   | column_val TK_IS TK_NULL
 579         {
 580             $$ = EXPR_unary( info, $1, OP_ISNULL );
 581             if( !$$ )
 582                 YYABORT;
 583         }
 584   | column_val TK_IS TK_NOT TK_NULL
 585         {
 586             $$ = EXPR_unary( info, $1, OP_NOTNULL );
 587             if( !$$ )
 588                 YYABORT;
 589         }
 590     ;
 591
 592 val:
 593     column_val
 594   | const_val
 595     ;
 596
 597 constlist:
 598     const_val
 599         {
 600             $$ = parser_alloc_column( info, NULL, NULL );
 601             if( !$$ )
 602                 YYABORT;
 603             $$->val = $1;
 604         }
 605   | const_val TK_COMMA constlist
 606         {
 607             $$ = parser_alloc_column( info, NULL, NULL );
 608             if( !$$ )
 609                 YYABORT;
 610             $$->val = $1;
 611             $$->next = $3;
 612         }
 613     ;
 614
 615 update_assign_list:
 616     column_assignment
 617   | column_assignment TK_COMMA update_assign_list
 618         {
 619             $$ = $1;
 620             $$->next = $3;
 621         }
 622     ;
 623
 624 column_assignment:
 625     column TK_EQ const_val
 626         {
 627             $$ = $1;
 628             $$->val = $3;
 629         }
 630     ;
 631
 632 const_val:
 633     number
 634         {
 635             $$ = EXPR_ival( info, $1 );
 636             if( !$$ )
 637                 YYABORT;
 638         }
 639   | TK_MINUS number %prec TK_NEGATION
 640         {
 641             $$ = EXPR_ival( info, -$2 );
 642             if( !$$ )
 643                 YYABORT;
 644         }
 645   | TK_STRING
 646         {
 647             $$ = EXPR_sval( info, &$1 );
 648             if( !$$ )
 649                 YYABORT;
 650         }
 651   | TK_WILDCARD
 652         {
 653             $$ = EXPR_wildcard( info );
 654             if( !$$ )
 655                 YYABORT;
 656         }
 657    | TK_NULL
 658         {
 659             $$ = EXPR_sval( info, NULL );
 660             if ( !$$ )
 661                 YYABORT;
 662         }
 663     ;
 664
 665 column_val:
 666     column
 667         {
 668             $$ = EXPR_column( info, $1 );
 669             if( !$$ )
 670                 YYABORT;
 671         }
 672     ;
 673
 674 column:
 675     table TK_DOT id
 676         {
 677             $$ = parser_alloc_column( info, $1, $3 );
 678             if( !$$ )
 679                 YYABORT;
 680         }
 681   | id
 682         {
 683             $$ = parser_alloc_column( info, NULL, $1 );
 684             if( !$$ )
 685                 YYABORT;
 686         }
 687     ;
 688
 689 selcolumn:
 690     table TK_DOT id
 691         {
 692             $$ = parser_alloc_column( info, $1, $3 );
 693             if( !$$ )
 694                 YYABORT;
 695         }
 696   | id
 697         {
 698             $$ = parser_alloc_column( info, NULL, $1 );
 699             if( !$$ )
 700                 YYABORT;
 701         }
 702   | string
 703         {
 704             $$ = parser_alloc_column( info, NULL, $1 );
 705             if( !$$ )
 706                 YYABORT;
 707         }
 708     ;
 709
 710 table:
 711     id
 712         {
 713             $$ = $1;
 714         }
 715     ;
 716
 717 id:
 718     TK_ID
 719         {
 720             if ( SQL_getstring( info, &$1, &$$ ) != ERROR_SUCCESS || !$$ )
 721                 YYABORT;
 722         }
 723     ;
 724
 725 string:
 726     TK_STRING
 727         {
 728             if ( SQL_getstring( info, &$1, &$$ ) != ERROR_SUCCESS || !$$ )
 729                 YYABORT;
 730         }
 731     ;
 732
 733 number:
 734     TK_INTEGER
 735         {
 736             $$ = SQL_getint( info );
 737         }
 738     ;
 739
 740 %%
 741
 742 static LPWSTR parser_add_table( void *info, LPCWSTR list, LPCWSTR table )
 743 {
 744     static const WCHAR space[] = {' ',0};
 745     DWORD len = lstrlenW( list ) + lstrlenW( table ) + 2;
 746     LPWSTR ret;
 747
 748     ret = parser_alloc( info, len * sizeof(WCHAR) );
 749     if( ret )
 750     {
 751         lstrcpyW( ret, list );
 752         lstrcatW( ret, space );
 753         lstrcatW( ret, table );
 754     }
 755     return ret;
 756 }
 757
 758 static void *parser_alloc( void *info, unsigned int sz )
 759 {
 760     SQL_input* sql = (SQL_input*) info;
 761     struct list *mem;
 762
 763     mem = msi_alloc( sizeof (struct list) + sz );
 764     list_add_tail( sql->mem, mem );
 765     return &mem[1];
 766 }
 767
 768 static column_info *parser_alloc_column( void *info, LPCWSTR table, LPCWSTR column )
 769 {
 770     column_info *col;
 771
 772     col = parser_alloc( info, sizeof (*col) );
 773     if( col )
 774     {
 775         col->table = table;
 776         col->column = column;
 777         col->val = NULL;
 778         col->type = 0;
 779         col->next = NULL;
 780     }
 781
 782     return col;
 783 }
 784
 785 static int sql_lex( void *SQL_lval, SQL_input *sql )
 786 {
 787     int token, skip;
 788     struct sql_str * str = SQL_lval;
 789
 790     do
 791     {
 792         sql->n += sql->len;
 793         if( ! sql->command[sql->n] )
 794             return 0;  /* end of input */
 795
 796         /* TRACE("string : %s\n", debugstr_w(&sql->command[sql->n])); */
 797         sql->len = sqliteGetToken( &sql->command[sql->n], &token, &skip );
 798         if( sql->len==0 )
 799             break;
 800         str->data = &sql->command[sql->n];
 801         str->len = sql->len;
 802         sql->n += skip;
 803     }
 804     while( token == TK_SPACE );
 805
 806     /* TRACE("token : %d (%s)\n", token, debugstr_wn(&sql->command[sql->n], sql->len)); */
 807
 808     return token;
 809 }
 810
 811 UINT SQL_getstring( void *info, const struct sql_str *strdata, LPWSTR *str )
 812 {
 813     LPCWSTR p = strdata->data;
 814     UINT len = strdata->len;
 815
 816     /* match quotes */
 817     if( ( (p[0]=='`') && (p[len-1]!='`') ) ||
 818         ( (p[0]=='\'') && (p[len-1]!='\'') ) )
 819         return ERROR_FUNCTION_FAILED;
 820
 821     /* if there are quotes, remove them */
 822     if( ( (p[0]=='`') && (p[len-1]=='`') ) ||
 823         ( (p[0]=='\'') && (p[len-1]=='\'') ) )
 824     {
 825         p++;
 826         len -= 2;
 827     }
 828     *str = parser_alloc( info, (len + 1)*sizeof(WCHAR) );
 829     if( !*str )
 830         return ERROR_OUTOFMEMORY;
 831     memcpy( *str, p, len*sizeof(WCHAR) );
 832     (*str)[len]=0;
 833
 834     return ERROR_SUCCESS;
 835 }
 836
 837 INT SQL_getint( void *info )
 838 {
 839     SQL_input* sql = (SQL_input*) info;
 840     LPCWSTR p = &sql->command[sql->n];
 841     INT i, r = 0;
 842
 843     for( i=0; i<sql->len; i++ )
 844     {
 845         if( '0' > p[i] || '9' < p[i] )
 846         {
 847             ERR("should only be numbers here!\n");
 848             break;
 849         }
 850         r = (p[i]-'0') + r*10;
 851     }
 852
 853     return r;
 854 }
 855
 856 static int sql_error( SQL_input *info, const char *str )
 857 {
 858     return 0;
 859 }
 860
 861 static struct expr * EXPR_wildcard( void *info )
 862 {
 863     struct expr *e = parser_alloc( info, sizeof *e );
 864     if( e )
 865     {
 866         e->type = EXPR_WILDCARD;
 867     }
 868     return e;
 869 }
 870
 871 static struct expr * EXPR_complex( void *info, struct expr *l, UINT op, struct expr *r )
 872 {
 873     struct expr *e = parser_alloc( info, sizeof *e );
 874     if( e )
 875     {
 876         e->type = EXPR_COMPLEX;
 877         e->u.expr.left = l;
 878         e->u.expr.op = op;
 879         e->u.expr.right = r;
 880     }
 881     return e;
 882 }
 883
 884 static struct expr * EXPR_unary( void *info, struct expr *l, UINT op )
 885 {
 886     struct expr *e = parser_alloc( info, sizeof *e );
 887     if( e )
 888     {
 889         e->type = EXPR_UNARY;
 890         e->u.expr.left = l;
 891         e->u.expr.op = op;
 892         e->u.expr.right = NULL;
 893     }
 894     return e;
 895 }
 896
 897 static struct expr * EXPR_column( void *info, const column_info *column )
 898 {
 899     struct expr *e = parser_alloc( info, sizeof *e );
 900     if( e )
 901     {
 902         e->type = EXPR_COLUMN;
 903         e->u.column.unparsed.column = column->column;
 904         e->u.column.unparsed.table = column->table;
 905     }
 906     return e;
 907 }
 908
 909 static struct expr * EXPR_ival( void *info, int val )
 910 {
 911     struct expr *e = parser_alloc( info, sizeof *e );
 912     if( e )
 913     {
 914         e->type = EXPR_IVAL;
 915         e->u.ival = val;
 916     }
 917     return e;
 918 }
 919
 920 static struct expr * EXPR_sval( void *info, const struct sql_str *str )
 921 {
 922     struct expr *e = parser_alloc( info, sizeof *e );
 923     if( e )
 924     {
 925         e->type = EXPR_SVAL;
 926         if( !str) e->u.sval = NULL;
 927         else if( SQL_getstring( info, str, (LPWSTR *)&e->u.sval ) != ERROR_SUCCESS )
 928             return NULL; /* e will be freed by query destructor */
 929     }
 930     return e;
 931 }
 932
 933 static void swap_columns( column_info **cols, column_info *A, int idx )
 934 {
 935     column_info *preA = NULL, *preB = NULL, *B, *ptr;
 936     int i = 0;
 937
 938     B = NULL;
 939     ptr = *cols;
 940     while( ptr )
 941     {
 942         if( i++ == idx )
 943             B = ptr;
 944         else if( !B )
 945             preB = ptr;
 946
 947         if( ptr->next == A )
 948             preA = ptr;
 949
 950         ptr = ptr->next;
 951     }
 952
 953     if( preB ) preB->next = A;
 954     if( preA ) preA->next = B;
 955     ptr = A->next;
 956     A->next = B->next;
 957     B->next = ptr;
 958     if( idx == 0 )
 959       *cols = A;
 960 }
 961
 962 static BOOL SQL_MarkPrimaryKeys( column_info **cols,
 963                                  column_info *keys )
 964 {
 965     column_info *k;
 966     BOOL found = TRUE;
 967     int count;
 968
 969     for( k = keys, count = 0; k && found; k = k->next, count++ )
 970     {
 971         column_info *c;
 972         int idx;
 973
 974         found = FALSE;
 975         for( c = *cols, idx = 0; c && !found; c = c->next, idx++ )
 976         {
 977             if( wcscmp( k->column, c->column ) )
 978                 continue;
 979             c->type |= MSITYPE_KEY;
 980             found = TRUE;
 981             if (idx != count)
 982                 swap_columns( cols, c, count );
 983         }
 984     }
 985
 986     return found;
 987 }
 988
 989 UINT MSI_ParseSQL( MSIDATABASE *db, LPCWSTR command, MSIVIEW **phview,
 990                    struct list *mem )
 991 {
 992     SQL_input sql;
 993     int r;
 994
 995     *phview = NULL;
 996
 997     sql.db = db;
 998     sql.command = command;
 999     sql.n = 0;
1000     sql.len = 0;
1001     sql.r = ERROR_BAD_QUERY_SYNTAX;
1002     sql.view = phview;
1003     sql.mem = mem;
1004
1005     r = sql_parse(&sql);
1006
1007     TRACE("Parse returned %d\n", r);
1008     if( r )
1009     {
1010         if (*sql.view)
1011         {
1012             (*sql.view)->ops->delete(*sql.view);
1013             *sql.view = NULL;
1014         }
1015         return sql.r;
1016     }
1017
1018     return ERROR_SUCCESS;
1019 }