sync msi with wine 1.1.35
[reactos.git] / 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 #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 }