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