← Back to branch summary

~ubuntu-branches/ubuntu/vivid/grass/vivid-proposed

« back to all changes in this revision

Viewing changes to lib/db/sqlp/yac.y

  • Committer: Package Import Robot
  • Author(s): Bas Couwenberg
  • Date: 2015-02-20 23:12:08 UTC
  • mfrom: (8.2.6 experimental)
  • Revision ID: package-import@ubuntu.com-20150220231208-1u6qvqm84v430b10
Tags: 7.0.0-1~exp1
* New upstream release.
* Update python-ctypes-ternary.patch to use if/else instead of and/or.
* Drop check4dev patch, rely on upstream check.
* Add build dependency on libpq-dev to grass-dev for libpq-fe.h.
* Drop patches applied upstream, refresh remaining patches.
* Update symlinks for images switched from jpg to png.

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/db/sqlp/yac.y
1
 
/*****************************************************************************
2
 
*
3
 
* MODULE:       SQL statement parser library 
4
 
*               
5
 
* AUTHOR(S):    lex.l and yac.y were originaly taken from unixODBC and
6
 
*               probably written by Peter Harvey <pharvey@codebydesigns.com>,
7
 
*               modifications and other code by Radim Blazek
8
 
*
9
 
* PURPOSE:      Parse input string containing SQL statement to 
10
 
*               SQLPSTMT structure.
11
 
*               SQL parser may be used by simple database drivers. 
12
 
*
13
 
* COPYRIGHT:    (C) 2000 by the GRASS Development Team
14
 
*
15
 
*               This program is free software under the GNU General Public
16
 
*               License (>=v2). Read the file COPYING that comes with GRASS
17
 
*               for details.
18
 
*
19
 
*****************************************************************************/
20
 
 
21
 
%{
22
 
#include <stdlib.h>
23
 
#include <string.h>
24
 
#include <math.h>
25
 
#include <grass/sqlp.h>
26
 
 
27
 
#define YYDEBUG 1
28
 
#define YYERROR_VERBOSE 1
29
 
 
30
 
%}
31
 
        
32
 
        /* symbolic tokens */
33
 
 
34
 
%union {
35
 
        int    intval;
36
 
        double floatval;
37
 
        char   *strval;
38
 
        int    subtok;
39
 
        SQLPNODE   *node;
40
 
}
41
 
 
42
 
        /* operators */
43
 
%type <node>    y_column
44
 
%type <node>    y_value
45
 
%type <node>    y_atom
46
 
%type <node>    y_term
47
 
%type <node>    y_product
48
 
%type <node>    y_expression
49
 
%type <node>    y_comparison
50
 
%type <node>    y_boolean
51
 
%type <node>    y_sub_condition2
52
 
%type <node>    y_sub_condition
53
 
%type <node>    y_condition
54
 
 
55
 
        /* literal keyword tokens */
56
 
%token <strval> COMPARISON_OPERATOR
57
 
%token <strval> NAME
58
 
%token <strval> STRING
59
 
%token <intval> INTNUM 
60
 
%token <floatval> FLOATNUM
61
 
 
62
 
%token ADD
63
 
%token DROP
64
 
%token COLUMN
65
 
%token EQUAL
66
 
%token SELECT FROM WHERE
67
 
%token DELETE
68
 
%token INSERT INTO VALUES
69
 
%token UPDATE SET
70
 
%token AND
71
 
%token OR
72
 
%token NOT
73
 
%token ALTER TABLE
74
 
%token CREATE
75
 
%token NULL_VALUE
76
 
%token VARCHAR
77
 
%token INT
78
 
%token INTEGER
79
 
%token DOUBLE
80
 
%token PRECISION
81
 
%token DATE
82
 
%token TIME
83
 
%token ORDER BY
84
 
%token IS
85
 
%token ASC
86
 
%token DESC
87
 
 
88
 
%{
89
 
 
90
 
extern int yylex(void);
91
 
 
92
 
%}
93
 
 
94
 
%%
95
 
 
96
 
y_sql:  
97
 
                y_alter
98
 
        |       y_create
99
 
        |       y_drop
100
 
        |       y_insert
101
 
        |       y_select
102
 
        |       y_update
103
 
        |       y_delete
104
 
        |       y_sql ';'
105
 
        ;
106
 
        
107
 
y_alter:
108
 
                ALTER TABLE y_table ADD COLUMN y_columndef      { sqpCommand(SQLP_ADD_COLUMN); }
109
 
        |       ALTER TABLE y_table ADD y_columndef             { sqpCommand(SQLP_ADD_COLUMN); }
110
 
        |       ALTER TABLE y_table DROP COLUMN NAME            { sqpCommand(SQLP_DROP_COLUMN); sqpColumn($6);}
111
 
        ;
112
 
        
113
 
y_create:
114
 
                CREATE TABLE y_table '(' y_columndefs ')'       { sqpCommand(SQLP_CREATE); }
115
 
        ;
116
 
        
117
 
y_drop:
118
 
                DROP TABLE y_table                              { sqpCommand(SQLP_DROP); }
119
 
        ;
120
 
 
121
 
y_select:
122
 
                SELECT y_columns FROM y_table                   { sqpCommand(SQLP_SELECT); }
123
 
        |       SELECT y_columns FROM y_table WHERE y_condition { sqpCommand(SQLP_SELECT); }
124
 
        |       SELECT y_columns FROM y_table ORDER BY y_order  { sqpCommand(SQLP_SELECT); }
125
 
        |       SELECT y_columns FROM y_table WHERE y_condition ORDER BY y_order { sqpCommand(SQLP_SELECT); }
126
 
        ;
127
 
        
128
 
y_delete:
129
 
                DELETE FROM y_table                             { sqpCommand(SQLP_DELETE); }
130
 
        |       DELETE FROM y_table WHERE y_condition           { sqpCommand(SQLP_DELETE); }
131
 
        ;
132
 
 
133
 
y_insert:
134
 
                INSERT INTO y_table y_values                    { sqpCommand(SQLP_INSERT); }
135
 
        |       INSERT INTO y_table '(' y_columns ')' y_values  { sqpCommand(SQLP_INSERT); }
136
 
        ;
137
 
 
138
 
y_update:
139
 
                UPDATE y_table SET y_assignments                { sqpCommand(SQLP_UPDATE); }
140
 
        |       UPDATE y_table SET y_assignments WHERE y_condition      { sqpCommand(SQLP_UPDATE); }
141
 
 
142
 
        ;
143
 
        
144
 
y_columndefs:
145
 
                y_columndef
146
 
        |       y_columndefs ',' y_columndef
147
 
        ;
148
 
 
149
 
y_columndef:
150
 
                NAME VARCHAR '(' INTNUM ')'     { sqpColumnDef( $1, SQLP_VARCHAR, $4, 0 ); }
151
 
        |       NAME INT                        { sqpColumnDef( $1, SQLP_INTEGER,  0, 0 ); }
152
 
        |       NAME INTEGER                    { sqpColumnDef( $1, SQLP_INTEGER,  0, 0 ); }
153
 
        |       NAME DOUBLE                     { sqpColumnDef( $1, SQLP_DOUBLE,   0, 0 ); }
154
 
        |       NAME DOUBLE PRECISION           { sqpColumnDef( $1, SQLP_DOUBLE,   0, 0 ); }
155
 
        |       NAME DATE                       { sqpColumnDef( $1, SQLP_DATE,     0, 0 ); }
156
 
        |       NAME TIME                       { sqpColumnDef( $1, SQLP_TIME,     0, 0 ); }
157
 
        ;
158
 
 
159
 
y_columns:
160
 
        '*'
161
 
        |       y_column_list
162
 
        ;
163
 
        
164
 
y_column_list:
165
 
                NAME                            { sqpColumn( $1 ); }
166
 
        |       y_column_list ',' NAME          { sqpColumn( $3 ); }
167
 
        ;
168
 
 
169
 
y_table:
170
 
                NAME                            { sqpTable( $1 ); }
171
 
        ;
172
 
        
173
 
y_values:
174
 
                VALUES '(' y_value_list ')'
175
 
        ;
176
 
 
177
 
y_value_list:
178
 
                NULL_VALUE                      { sqpValue( NULL,  0, 0.0, SQLP_NULL ); }
179
 
        |       STRING                          { sqpValue( $1,    0, 0.0, SQLP_S ); }
180
 
        |       INTNUM                          { sqpValue( NULL, $1, 0.0, SQLP_I ); }
181
 
        |      '-' INTNUM                       { sqpValue( NULL, -$2, 0.0, SQLP_I ); }
182
 
        |       FLOATNUM                        { sqpValue( NULL,  0,  $1, SQLP_D ); }
183
 
        |       '-' FLOATNUM                    { sqpValue( NULL, 0, -$2, SQLP_D ); }
184
 
        |       y_value_list ',' NULL_VALUE     { sqpValue( NULL,  0, 0.0, SQLP_NULL ); }
185
 
        |       y_value_list ',' STRING         { sqpValue( $3,    0, 0.0, SQLP_S ); }
186
 
        |       y_value_list ',' INTNUM         { sqpValue( NULL, $3, 0.0, SQLP_I ); }
187
 
        |       y_value_list ',' '-' INTNUM     { sqpValue( NULL, -$4, 0.0, SQLP_I ); }
188
 
        |       y_value_list ',' FLOATNUM       { sqpValue( NULL,  0,  $3, SQLP_D ); }
189
 
        |       y_value_list ',' '-' FLOATNUM   { sqpValue( NULL, 0, -$4, SQLP_D ); }
190
 
        ;
191
 
 
192
 
y_assignments:
193
 
                y_assignment
194
 
        |       y_assignments ',' y_assignment
195
 
        ;
196
 
        
197
 
y_assignment:
198
 
                NAME EQUAL NULL_VALUE   { sqpAssignment( $1, NULL,  0, 0.0, NULL, SQLP_NULL ); }
199
 
/*        |     NAME EQUAL STRING       { sqpAssignment( $1,   $3,  0, 0.0, NULL, SQLP_S ); }
200
 
        |       NAME EQUAL INTNUM       { sqpAssignment( $1, NULL, $3, 0.0, NULL, SQLP_I ); }
201
 
        |       NAME EQUAL FLOATNUM     { sqpAssignment( $1, NULL,  0,  $3, NULL, SQLP_D ); }
202
 
*/        |       NAME EQUAL y_expression { sqpAssignment( $1, NULL, 0, 0.0, $3, SQLP_EXPR ); }
203
 
        ;
204
 
 
205
 
y_condition:    
206
 
                y_sub_condition { 
207
 
                    $$ = $1;
208
 
                    sqlpStmt->upperNodeptr = $$; 
209
 
                }       
210
 
        ;
211
 
 
212
 
y_sub_condition:        
213
 
                y_sub_condition2 { $$ = $1; }
214
 
        |       y_sub_condition OR y_sub_condition2 { $$ = sqpNewExpressionNode (SQLP_OR, $1, $3); }
215
 
        ;
216
 
 
217
 
y_sub_condition2:       
218
 
                y_boolean { $$ = $1; }
219
 
        |       y_sub_condition2 AND y_boolean { $$ = sqpNewExpressionNode (SQLP_AND, $1, $3); }
220
 
        ;
221
 
 
222
 
y_boolean:      
223
 
                y_comparison { $$ = $1; }
224
 
        |       '(' y_sub_condition ')' { $$ = $2; }
225
 
        |       NOT y_boolean { $$ = sqpNewExpressionNode ( SQLP_NOT, NULL, $2); }
226
 
        ;
227
 
 
228
 
/* Note EQUAL should be one of COMPARISON but there is maybe some reason ... */
229
 
y_comparison:
230
 
                y_expression EQUAL y_expression {
231
 
                    $$ = sqpNewExpressionNode ( SQLP_EQ, $1, $3);
232
 
                }
233
 
        |       y_expression COMPARISON_OPERATOR y_expression {
234
 
                    $$ = sqpNewExpressionNode ( sqpOperatorCode($2), $1, $3);
235
 
                }
236
 
        |       y_expression IS NULL_VALUE {
237
 
                    $$ = sqpNewExpressionNode ( SQLP_ISNULL, NULL, $1);
238
 
                }
239
 
        |       y_expression NOT NULL_VALUE {
240
 
                    $$ = sqpNewExpressionNode ( SQLP_NOTNULL, NULL, $1);
241
 
                }
242
 
        ;       
243
 
 
244
 
/* Mathematical expression */
245
 
y_expression:
246
 
                y_product                       { $$ = $1; }
247
 
        |       y_expression '+' y_product {
248
 
                    $$ = sqpNewExpressionNode ( sqpOperatorCode("+"), $1, $3 );
249
 
                }
250
 
        |       y_expression '-' y_product {
251
 
                    $$ = sqpNewExpressionNode ( sqpOperatorCode("-"), $1, $3 );
252
 
                }
253
 
        ;
254
 
 
255
 
y_product:
256
 
                y_term                          { $$ = $1; }
257
 
        |       y_product '*' y_term {
258
 
                    $$ = sqpNewExpressionNode ( sqpOperatorCode("*"), $1, $3 );
259
 
                }
260
 
        |       y_product '/' y_term {
261
 
                    $$ = sqpNewExpressionNode ( sqpOperatorCode("/"), $1, $3 );
262
 
                }
263
 
        ;
264
 
 
265
 
y_term:
266
 
                y_atom                          { $$ = $1; }
267
 
        |       '-' y_term {
268
 
                    $$ = sqpNewExpressionNode ( sqpOperatorCode("-"), sqpNewValueNode ( NULL, 0, 0.0,  SQLP_I ), $2 );
269
 
                }
270
 
        ;
271
 
 
272
 
y_atom:
273
 
                y_value                         { $$ = $1; }
274
 
        |       y_column                        { $$ = $1; }
275
 
        |       '(' y_expression ')'            { $$ = $2; }
276
 
        ;
277
 
 
278
 
/* Value used in expressions */ 
279
 
y_value:
280
 
                STRING                          { $$ = sqpNewValueNode (   $1,  0, 0.0,  SQLP_S ); }
281
 
        |       INTNUM                          { $$ = sqpNewValueNode ( NULL, $1, 0.0,  SQLP_I ); }
282
 
        |       FLOATNUM                        { $$ = sqpNewValueNode ( NULL,  0,  $1,  SQLP_D ); }
283
 
        ;
284
 
 
285
 
/* Column used in expressions */
286
 
y_column:
287
 
                NAME                            {$$ = sqpNewColumnNode (  $1 );}
288
 
        ;
289
 
 
290
 
y_order: y_order_asc | y_order_desc;
291
 
 
292
 
y_order_asc:
293
 
                NAME                            { sqpOrderColumn( $1, SORT_ASC ); }
294
 
        |       NAME ASC                        { sqpOrderColumn( $1, SORT_ASC ); }
295
 
        ;
296
 
y_order_desc:
297
 
                NAME DESC                       { sqpOrderColumn( $1, SORT_DESC ); }
298
 
        ;
299
 
%%
300
 
 
301