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