← Back to branch summary

~ubuntu-branches/ubuntu/precise/koffice/precise

« back to all changes in this revision

Viewing changes to kexi/kexidb/parser/sqlparser.y

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2010-09-21 15:36:35 UTC
  • mfrom: (1.4.1 upstream) (60.2.11 maverick)
  • Revision ID: james.westby@ubuntu.com-20100921153635-6tejqkiro2u21ydi
Tags: 1:2.2.2-0ubuntu3
Add kubuntu_03_fix-crash-on-closing-sqlite-connection-2.2.2.diff and
kubuntu_04_support-large-memo-values-for-msaccess-2.2.2.diff as
recommended by upstream http://kexi-
project.org/wiki/wikiview/index.php@Kexi2.2_Patches.html#sqlite_stab
ility

Show diffs side-by-side

added added

removed removed

Lines of Context:
kexi/kexidb/parser/sqlparser.y
 
1
/* This file is part of the KDE project
 
2
   Copyright (C) 2004 Lucijan Busch <lucijan@kde.org>
 
3
   Copyright (C) 2004, 2006 Jarosław Staniek <staniek@kde.org>
 
4
 
 
5
   This library is free software; you can redistribute it and/or
 
6
   modify it under the terms of the GNU Library General Public
 
7
   License as published by the Free Software Foundation; either
 
8
   version 2 of the License, or (at your option) any later version.
 
9
 
 
10
   This library is distributed in the hope that it will be useful,
 
11
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
13
   Library General Public License for more details.
 
14
 
 
15
   You should have received a copy of the GNU Library General Public License
 
16
   along with this library; see the file COPYING.LIB.  If not, write to
 
17
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 
18
   Boston, MA 02110-1301, USA.
 
19
*/
 
20
 
 
21
%token UMINUS
 
22
 
 
23
%token SQL_TYPE
 
24
%token SQL_ABS
 
25
%token ACOS
 
26
%token AMPERSAND
 
27
%token SQL_ABSOLUTE
 
28
%token ADA
 
29
%token ADD
 
30
%token ADD_DAYS
 
31
%token ADD_HOURS
 
32
%token ADD_MINUTES
 
33
%token ADD_MONTHS
 
34
%token ADD_SECONDS
 
35
%token ADD_YEARS
 
36
%token ALL
 
37
%token ALLOCATE
 
38
%token ALTER
 
39
%token AND
 
40
%token ANY
 
41
%token ARE
 
42
%token AS
 
43
%token ASIN
 
44
%token ASC
 
45
%token ASCII
 
46
%token ASSERTION
 
47
%token ATAN
 
48
%token ATAN2
 
49
%token AUTHORIZATION
 
50
%token AUTO_INCREMENT
 
51
%token AVG
 
52
%token BEFORE
 
53
%token SQL_BEGIN
 
54
%token BETWEEN
 
55
%token BIGINT
 
56
%token BINARY
 
57
%token BIT
 
58
%token BIT_LENGTH
 
59
%token BITWISE_SHIFT_LEFT
 
60
%token BITWISE_SHIFT_RIGHT
 
61
%token BREAK
 
62
%token BY
 
63
%token CASCADE
 
64
%token CASCADED
 
65
%token CASE
 
66
%token CAST
 
67
%token CATALOG
 
68
%token CEILING
 
69
%token CENTER
 
70
%token SQL_CHAR
 
71
%token CHAR_LENGTH
 
72
%token CHARACTER_STRING_LITERAL
 
73
%token CHECK
 
74
%token CLOSE
 
75
%token COALESCE
 
76
%token COBOL
 
77
%token COLLATE
 
78
%token COLLATION
 
79
%token COLUMN
 
80
%token COMMIT
 
81
%token COMPUTE
 
82
%token CONCAT
 
83
%token CONCATENATION /* || */
 
84
%token CONNECT
 
85
%token CONNECTION
 
86
%token CONSTRAINT
 
87
%token CONSTRAINTS
 
88
%token CONTINUE
 
89
%token CONVERT
 
90
%token CORRESPONDING
 
91
%token COS
 
92
%token COT
 
93
%token COUNT
 
94
%token CREATE
 
95
%token CURDATE
 
96
%token CURRENT
 
97
%token CURRENT_DATE
 
98
%token CURRENT_TIME
 
99
%token CURRENT_TIMESTAMP
 
100
%token CURTIME
 
101
%token CURSOR
 
102
%token DATABASE
 
103
%token SQL_DATE
 
104
%token DATE_FORMAT
 
105
%token DATE_REMAINDER
 
106
%token DATE_VALUE
 
107
%token DAY
 
108
%token DAYOFMONTH
 
109
%token DAYOFWEEK
 
110
%token DAYOFYEAR
 
111
%token DAYS_BETWEEN
 
112
%token DEALLOCATE
 
113
%token DEC
 
114
%token DECLARE
 
115
%token DEFAULT
 
116
%token DEFERRABLE
 
117
%token DEFERRED
 
118
%token SQL_DELETE
 
119
%token DESC
 
120
%token DESCRIBE
 
121
%token DESCRIPTOR
 
122
%token DIAGNOSTICS
 
123
%token DICTIONARY
 
124
%token DIRECTORY
 
125
%token DISCONNECT
 
126
%token DISPLACEMENT
 
127
%token DISTINCT
 
128
%token DOMAIN_TOKEN
 
129
%token SQL_DOUBLE
 
130
%token DOUBLE_QUOTED_STRING
 
131
%token DROP
 
132
%token ELSE
 
133
%token END
 
134
%token END_EXEC
 
135
%token EQUAL
 
136
%token ESCAPE
 
137
%token EXCEPT
 
138
%token SQL_EXCEPTION
 
139
%token EXEC
 
140
%token EXECUTE
 
141
%token EXISTS
 
142
%token EXP
 
143
%token EXPONENT
 
144
%token EXTERNAL
 
145
%token EXTRACT
 
146
%token SQL_FALSE
 
147
%token FETCH
 
148
%token FIRST
 
149
%token SQL_FLOAT
 
150
%token FLOOR
 
151
%token FN
 
152
%token FOR
 
153
%token FOREIGN
 
154
%token FORTRAN
 
155
%token FOUND
 
156
%token FOUR_DIGITS
 
157
%token FROM
 
158
%token FULL
 
159
%token GET
 
160
%token GLOBAL
 
161
%token GO
 
162
%token GOTO
 
163
%token GRANT
 
164
%token GREATER_OR_EQUAL
 
165
//%token GREATER_THAN
 
166
//conflict %token GROUP
 
167
%token HAVING
 
168
%token HOUR
 
169
%token HOURS_BETWEEN
 
170
%token IDENTITY
 
171
%token IFNULL
 
172
%token SQL_IGNORE
 
173
%token IMMEDIATE
 
174
%token SQL_IN
 
175
%token INCLUDE
 
176
%token INDEX
 
177
%token INDICATOR
 
178
%token INITIALLY
 
179
%token INNER
 
180
%token SQL_INPUT
 
181
%token INSENSITIVE
 
182
%token INSERT
 
183
%token INTEGER
 
184
%token INTERSECT
 
185
%token INTERVAL
 
186
%token INTO
 
187
%token IS
 
188
%token ISOLATION
 
189
%token JOIN
 
190
%token JUSTIFY
 
191
%token KEY
 
192
%token LANGUAGE
 
193
%token LAST
 
194
%token LCASE
 
195
%token LEFT
 
196
%token LENGTH
 
197
%token LESS_OR_EQUAL
 
198
//%token LESS_THAN
 
199
%token LEVEL
 
200
%token LIKE
 
201
%token LINE_WIDTH
 
202
%token LOCAL
 
203
%token LOCATE
 
204
%token LOG
 
205
%token SQL_LONG
 
206
%token LOWER
 
207
%token LTRIM
 
208
%token LTRIP
 
209
%token MATCH
 
210
%token SQL_MAX
 
211
%token MICROSOFT
 
212
%token SQL_MIN
 
213
%token MINUS
 
214
%token MINUTE
 
215
%token MINUTES_BETWEEN
 
216
%token MOD
 
217
%token MODIFY
 
218
%token MODULE
 
219
%token MONTH
 
220
%token MONTHS_BETWEEN
 
221
%token MUMPS
 
222
%token NAMES
 
223
%token NATIONAL
 
224
%token NCHAR
 
225
%token NEXT
 
226
%token NODUP
 
227
%token NONE
 
228
%token NOT
 
229
%token NOT_EQUAL //<>
 
230
%token NOT_EQUAL2 //!=
 
231
%token NOW
 
232
%token SQL_NULL
 
233
%token SQL_IS
 
234
%token SQL_IS_NULL /*helper */
 
235
%token SQL_IS_NOT_NULL /*helper */
 
236
%token NULLIF
 
237
%token NUMERIC
 
238
%token OCTET_LENGTH
 
239
%token ODBC
 
240
%token OF
 
241
%token SQL_OFF
 
242
%token SQL_ON
 
243
%token ONLY
 
244
%token OPEN
 
245
%token OPTION
 
246
%token OR
 
247
%token ORDER
 
248
%token OUTER
 
249
%token OUTPUT
 
250
%token OVERLAPS
 
251
%token PAGE
 
252
%token PARTIAL
 
253
%token SQL_PASCAL
 
254
%token PERSISTENT
 
255
%token CQL_PI
 
256
%token PLI
 
257
%token POSITION
 
258
%token PRECISION
 
259
%token PREPARE
 
260
%token PRESERVE
 
261
%token PRIMARY
 
262
%token PRIOR
 
263
%token PRIVILEGES
 
264
%token PROCEDURE
 
265
%token PRODUCT
 
266
%token PUBLIC
 
267
%token QUARTER
 
268
%token QUIT
 
269
%token RAND
 
270
%token READ_ONLY
 
271
%token REAL
 
272
%token REFERENCES
 
273
%token REPEAT
 
274
%token REPLACE
 
275
%token RESTRICT
 
276
%token REVOKE
 
277
%token RIGHT
 
278
%token ROLLBACK
 
279
%token ROWS
 
280
%token RPAD
 
281
%token RTRIM
 
282
%token SCHEMA
 
283
%token SCREEN_WIDTH
 
284
%token SCROLL
 
285
%token SECOND
 
286
%token SECONDS_BETWEEN
 
287
%token SELECT
 
288
%token SEQUENCE
 
289
%token SETOPT
 
290
%token SET
 
291
%token SHOWOPT
 
292
%token SIGN
 
293
//%token SIMILAR
 
294
%token SIMILAR_TO /* helper */
 
295
%token NOT_SIMILAR_TO /* helper */
 
296
%token INTEGER_CONST
 
297
%token REAL_CONST
 
298
%token DATE_CONST
 
299
%token DATETIME_CONST
 
300
%token TIME_CONST
 
301
%token SIN
 
302
%token SQL_SIZE
 
303
%token SMALLINT
 
304
%token SOME
 
305
%token SPACE
 
306
%token SQL
 
307
%token SQL_TRUE
 
308
%token SQLCA
 
309
%token SQLCODE
 
310
%token SQLERROR
 
311
%token SQLSTATE
 
312
%token SQLWARNING
 
313
%token SQRT
 
314
%token STDEV
 
315
%token SUBSTRING
 
316
%token SUM
 
317
%token SYSDATE
 
318
%token SYSDATE_FORMAT
 
319
%token SYSTEM
 
320
%token TABLE
 
321
%token TAN
 
322
%token TEMPORARY
 
323
%token THEN
 
324
%token THREE_DIGITS
 
325
%token TIME
 
326
%token TIMESTAMP
 
327
%token TIMEZONE_HOUR
 
328
%token TIMEZONE_MINUTE
 
329
%token TINYINT
 
330
%token TO
 
331
%token TO_CHAR
 
332
%token TO_DATE
 
333
%token TRANSACTION
 
334
%token TRANSLATE
 
335
%token TRANSLATION
 
336
%token TRUNCATE
 
337
%token GENERAL_TITLE
 
338
%token TWO_DIGITS
 
339
%token UCASE
 
340
%token UNION
 
341
%token UNIQUE
 
342
%token SQL_UNKNOWN
 
343
//%token UNSIGNED_INTEGER
 
344
%token UPDATE
 
345
%token UPPER
 
346
%token USAGE
 
347
%token USER
 
348
%token IDENTIFIER
 
349
%token IDENTIFIER_DOT_ASTERISK
 
350
%token QUERY_PARAMETER
 
351
//%token ERROR_DIGIT_BEFORE_IDENTIFIER
 
352
%token USING
 
353
%token VALUE
 
354
%token VALUES
 
355
%token VARBINARY
 
356
%token VARCHAR
 
357
%token VARYING
 
358
%token VENDOR
 
359
%token VIEW
 
360
%token WEEK
 
361
%token WHEN
 
362
%token WHENEVER
 
363
%token WHERE
 
364
%token WHERE_CURRENT_OF
 
365
%token WITH
 
366
%token WORD_WRAPPED
 
367
%token WORK
 
368
%token WRAPPED
 
369
%token XOR
 
370
%token YEAR
 
371
%token YEARS_BETWEEN
 
372
 
 
373
%token SCAN_ERROR
 
374
%token __LAST_TOKEN /* sentinel */
 
375
 
 
376
%token '-' '+'
 
377
%token '*'
 
378
%token '%'
 
379
%token '@'
 
380
%token ';'
 
381
%token ','
 
382
%token '.'
 
383
%token '$'
 
384
//%token '<'
 
385
//%token '>'
 
386
%token '(' ')'
 
387
%token '?'
 
388
%token '\''
 
389
%token '/'
 
390
 
 
391
%type <stringValue> IDENTIFIER
 
392
%type <stringValue> IDENTIFIER_DOT_ASTERISK
 
393
%type <stringValue> QUERY_PARAMETER
 
394
%type <stringValue> CHARACTER_STRING_LITERAL
 
395
%type <stringValue> DOUBLE_QUOTED_STRING
 
396
 
 
397
/*
 
398
%type <field> ColExpression
 
399
%type <field> ColView
 
400
*/
 
401
%type <expr> ColExpression
 
402
%type <expr> ColWildCard
 
403
//%type <expr> ColView
 
404
%type <expr> ColItem
 
405
%type <exprList> ColViews
 
406
%type <expr> aExpr
 
407
%type <expr> aExpr2
 
408
%type <expr> aExpr3
 
409
%type <expr> aExpr4
 
410
%type <expr> aExpr5
 
411
%type <expr> aExpr6
 
412
%type <expr> aExpr7
 
413
%type <expr> aExpr8
 
414
%type <expr> aExpr9
 
415
%type <expr> aExpr10
 
416
%type <exprList> aExprList
 
417
%type <exprList> aExprList2
 
418
%type <expr> WhereClause
 
419
%type <orderByColumns> OrderByClause
 
420
%type <booleanValue> OrderByOption
 
421
%type <variantValue> OrderByColumnId
 
422
%type <selectOptions> SelectOptions
 
423
%type <expr> FlatTable
 
424
%type <exprList> Tables
 
425
%type <exprList> FlatTableList
 
426
%type <querySchema> SelectStatement
 
427
%type <querySchema> Select
 
428
/*todo : list*/
 
429
%type <querySchema> StatementList
 
430
/*todo: not onlu select*/
 
431
%type <querySchema> Statement
 
432
 
 
433
%type <colType> SQL_TYPE
 
434
%type <integerValue> INTEGER_CONST
 
435
%type <realValue> REAL_CONST
 
436
/*%type <integerValue> SIGNED_INTEGER */
 
437
 
 
438
%{
 
439
#ifndef YYDEBUG /* compat. */
 
440
# define YYDEBUG 0
 
441
#endif
 
442
#include <stdio.h>
 
443
#include <string.h>
 
444
#include <string>
 
445
#include <iostream>
 
446
#include <assert.h>
 
447
#include <limits.h>
 
448
//TODO OK?
 
449
#ifdef Q_WS_WIN
 
450
//workaround for bug on msvc
 
451
# undef LLONG_MIN
 
452
#endif
 
453
#ifndef LLONG_MAX
 
454
# define LLONG_MAX     0x7fffffffffffffffLL
 
455
#endif
 
456
#ifndef LLONG_MIN
 
457
# define LLONG_MIN     0x8000000000000000LL
 
458
#endif
 
459
#ifndef LLONG_MAX
 
460
# define ULLONG_MAX    0xffffffffffffffffLL
 
461
#endif
 
462
 
 
463
#ifdef _WIN32
 
464
# include <malloc.h>
 
465
#endif
 
466
 
 
467
#include <QObject>
 
468
#include <QList>
 
469
#include <QVariant>
 
470
 
 
471
#include <KDebug>
 
472
#include <KLocale>
 
473
 
 
474
#include <kexidb/connection.h>
 
475
#include <kexidb/queryschema.h>
 
476
#include <kexidb/field.h>
 
477
#include <kexidb/tableschema.h>
 
478
 
 
479
#include "parser.h"
 
480
#include "parser_p.h"
 
481
#include "sqltypes.h"
 
482
 
 
483
int yylex();
 
484
 
 
485
//      using namespace std;
 
486
using namespace KexiDB;
 
487
 
 
488
#define YY_NO_UNPUT
 
489
#define YYSTACK_USE_ALLOCA 1
 
490
#define YYMAXDEPTH 255
 
491
 
 
492
        extern "C"
 
493
        {
 
494
                int yywrap()
 
495
                {
 
496
                        return 1;
 
497
                }
 
498
        }
 
499
 
 
500
#if 0
 
501
        struct yyval
 
502
        {
 
503
                QString parserUserName;
 
504
                int integerValue;
 
505
                KexiDBField::ColumnType coltype;
 
506
        }
 
507
#endif
 
508
 
 
509
%}
 
510
 
 
511
%union {
 
512
        QString* stringValue;
 
513
        qint64 integerValue;
 
514
        bool booleanValue;
 
515
        struct realType realValue;
 
516
        KexiDB::Field::Type colType;
 
517
        KexiDB::Field *field;
 
518
        KexiDB::BaseExpr *expr;
 
519
        KexiDB::NArgExpr *exprList;
 
520
        KexiDB::ConstExpr *constExpr;
 
521
        KexiDB::QuerySchema *querySchema;
 
522
        SelectOptionsInternal *selectOptions;
 
523
        OrderByColumnInternal::List *orderByColumns;
 
524
        QVariant *variantValue;
 
525
}
 
526
 
 
527
//%left '=' NOT_EQUAL '>' GREATER_OR_EQUAL '<' LESS_OR_EQUAL LIKE '%' NOT
 
528
//%left '+' '-'
 
529
//%left ASTERISK SLASH
 
530
 
 
531
/* precedence: lowest to highest */
 
532
%left           UNION EXCEPT
 
533
%left           INTERSECT
 
534
%left           OR
 
535
%left           AND XOR
 
536
%right  NOT
 
537
//%right                '='
 
538
//%nonassoc     '<' '>'
 
539
//%nonassoc '=' '<' '>' "<=" ">=" "<>" ":=" LIKE ILIKE SIMILAR
 
540
//%nonassoc '=' LESS_THAN GREATER_THAN LESS_OR_EQUAL GREATER_OR_EQUAL NOT_EQUAL
 
541
%nonassoc '=' '<' '>'
 
542
//LESS_THAN GREATER_THAN 
 
543
%nonassoc LESS_OR_EQUAL GREATER_OR_EQUAL 
 
544
%nonassoc NOT_EQUAL NOT_EQUAL2
 
545
%nonassoc SQL_IN LIKE ILIKE SIMILAR_TO NOT_SIMILAR_TO
 
546
//%nonassoc     LIKE ILIKE SIMILAR
 
547
//%nonassoc     ESCAPE
 
548
//%nonassoc     OVERLAPS
 
549
%nonassoc       BETWEEN
 
550
//%nonassoc     IN_P
 
551
//%left         POSTFIXOP               // dummy for postfix Op rules 
 
552
//%left         Op OPERATOR             // multi-character ops and user-defined operators 
 
553
//%nonassoc     NOTNULL
 
554
//%nonassoc     ISNULL
 
555
//%nonassoc     IS NULL_P TRUE_P FALSE_P UNKNOWN // sets precedence for IS NULL, etc 
 
556
%left           '+' '-'
 
557
%left           '*' '/' '%'
 
558
%left           '^'
 
559
%left UMINUS
 
560
// Unary Operators 
 
561
//%left         AT ZONE                 // sets precedence for AT TIME ZONE
 
562
//%right                UMINUS
 
563
%left           '[' ']'
 
564
%left           '(' ')'
 
565
//%left         TYPECAST
 
566
%left           '.'
 
567
 
 
568
/*
 
569
 * These might seem to be low-precedence, but actually they are not part
 
570
 * of the arithmetic hierarchy at all in their use as JOIN operators.
 
571
 * We make them high-precedence to support their use as function names.
 
572
 * They wouldn't be given a precedence at all, were it not that we need
 
573
 * left-associativity among the JOIN rules themselves.
 
574
 */
 
575
/*%left         JOIN UNIONJOIN CROSS LEFT FULL RIGHT INNER_P NATURAL
 
576
*/
 
577
%%
 
578
 
 
579
TopLevelStatement :
 
580
StatementList
 
581
{
 
582
//todo: multiple statements
 
583
//todo: not only "select" statements
 
584
        parser->setOperation(Parser::OP_Select);
 
585
        parser->setQuerySchema($1);
 
586
}
 
587
;
 
588
 
 
589
StatementList:
 
590
Statement ';' StatementList
 
591
{
 
592
//todo: multiple statements
 
593
}
 
594
| Statement
 
595
| Statement ';'
 
596
{
 
597
        $$ = $1;
 
598
}
 
599
;
 
600
 
 
601
/*              Statement CreateTableStatement          { YYACCEPT; }
 
602
        | Statement SelectStatement             {  }
 
603
*/
 
604
Statement :
 
605
CreateTableStatement
 
606
{
 
607
YYACCEPT;
 
608
}
 
609
| SelectStatement
 
610
{
 
611
        $$ = $1;
 
612
}
 
613
;
 
614
 
 
615
CreateTableStatement :
 
616
CREATE TABLE IDENTIFIER
 
617
{
 
618
        parser->setOperation(Parser::OP_CreateTable);
 
619
        parser->createTable($3->toLatin1());
 
620
        delete $3;
 
621
}
 
622
'(' ColDefs ')'
 
623
;
 
624
 
 
625
ColDefs:
 
626
ColDefs ',' ColDef|ColDef
 
627
{
 
628
}
 
629
;
 
630
 
 
631
ColDef:
 
632
IDENTIFIER ColType
 
633
{
 
634
        KexiDBDbg << "adding field " << *$1;
 
635
        field->setName($1->toLatin1());
 
636
        parser->table()->addField(field);
 
637
        field = 0;
 
638
        delete $1;
 
639
}
 
640
| IDENTIFIER ColType ColKeys
 
641
{
 
642
        KexiDBDbg << "adding field " << *$1;
 
643
        field->setName(*$1);
 
644
        delete $1;
 
645
        parser->table()->addField(field);
 
646
 
 
647
//      if(field->isPrimaryKey())
 
648
//              parser->table()->addPrimaryKey(field->name());
 
649
 
 
650
//      delete field;
 
651
//      field = 0;
 
652
}
 
653
;
 
654
 
 
655
ColKeys:
 
656
ColKeys ColKey|ColKey
 
657
{
 
658
}
 
659
;
 
660
 
 
661
ColKey:
 
662
PRIMARY KEY
 
663
{
 
664
        field->setPrimaryKey(true);
 
665
        KexiDBDbg << "primary";
 
666
}
 
667
| NOT SQL_NULL
 
668
{
 
669
        field->setNotNull(true);
 
670
        KexiDBDbg << "not_null";
 
671
}
 
672
| AUTO_INCREMENT
 
673
{
 
674
        field->setAutoIncrement(true);
 
675
        KexiDBDbg << "ainc";
 
676
}
 
677
;
 
678
 
 
679
ColType:
 
680
SQL_TYPE
 
681
{
 
682
        field = new Field();
 
683
        field->setType($1);
 
684
}
 
685
| SQL_TYPE '(' INTEGER_CONST ')'
 
686
{
 
687
        KexiDBDbg << "sql + length";
 
688
        field = new Field();
 
689
        field->setPrecision($3);
 
690
        field->setType($1);
 
691
}
 
692
| VARCHAR '(' INTEGER_CONST ')'
 
693
{
 
694
        field = new Field();
 
695
        field->setPrecision($3);
 
696
        field->setType(Field::Text);
 
697
}
 
698
|
 
699
{
 
700
        // SQLITE compatibillity
 
701
        field = new Field();
 
702
        field->setType(Field::InvalidType);
 
703
}
 
704
;
 
705
 
 
706
SelectStatement:
 
707
Select ColViews
 
708
{
 
709
        KexiDBDbg << "Select ColViews=" << $2->debugString();
 
710
 
 
711
        if (!($$ = buildSelectQuery( $1, $2 )))
 
712
                return 0;
 
713
}
 
714
| Select ColViews Tables
 
715
{
 
716
        if (!($$ = buildSelectQuery( $1, $2, $3 )))
 
717
                return 0;
 
718
}
 
719
| Select Tables
 
720
{
 
721
        KexiDBDbg << "Select ColViews Tables";
 
722
        if (!($$ = buildSelectQuery( $1, 0, $2 )))
 
723
                return 0;
 
724
}
 
725
| Select ColViews SelectOptions
 
726
{
 
727
        KexiDBDbg << "Select ColViews Conditions";
 
728
        if (!($$ = buildSelectQuery( $1, $2, 0, $3 )))
 
729
                return 0;
 
730
}
 
731
| Select ColViews Tables SelectOptions
 
732
{
 
733
        KexiDBDbg << "Select ColViews Tables SelectOptions";
 
734
        if (!($$ = buildSelectQuery( $1, $2, $3, $4 )))
 
735
                return 0;
 
736
}
 
737
;
 
738
 
 
739
Select:
 
740
SELECT
 
741
{
 
742
        KexiDBDbg << "SELECT";
 
743
//      parser->createSelect();
 
744
//      parser->setOperation(Parser::OP_Select);
 
745
        $$ = new QuerySchema();
 
746
}
 
747
;
 
748
 
 
749
SelectOptions: /* todo: more options (having, group by, limit...) */
 
750
WhereClause
 
751
{
 
752
        KexiDBDbg << "WhereClause";
 
753
        $$ = new SelectOptionsInternal;
 
754
        $$->whereExpr = $1;
 
755
}
 
756
| ORDER BY OrderByClause
 
757
{
 
758
        KexiDBDbg << "OrderByClause";
 
759
        $$ = new SelectOptionsInternal;
 
760
        $$->orderByColumns = $3;
 
761
}
 
762
| WhereClause ORDER BY OrderByClause
 
763
{
 
764
        KexiDBDbg << "WhereClause ORDER BY OrderByClause";
 
765
        $$ = new SelectOptionsInternal;
 
766
        $$->whereExpr = $1;
 
767
        $$->orderByColumns = $4;
 
768
} 
 
769
| ORDER BY OrderByClause WhereClause
 
770
{
 
771
        KexiDBDbg << "OrderByClause WhereClause";
 
772
        $$ = new SelectOptionsInternal;
 
773
        $$->whereExpr = $4;
 
774
        $$->orderByColumns = $3;
 
775
}
 
776
;
 
777
 
 
778
WhereClause:
 
779
WHERE aExpr
 
780
{
 
781
        $$ = $2;
 
782
}
 
783
;
 
784
 
 
785
/* todo: support "ORDER BY NULL" as described here http://dev.mysql.com/doc/refman/5.1/en/select.html */
 
786
/* todo: accept expr and position as well */
 
787
OrderByClause:
 
788
OrderByColumnId
 
789
{
 
790
        KexiDBDbg << "ORDER BY IDENTIFIER";
 
791
        $$ = new OrderByColumnInternal::List;
 
792
        OrderByColumnInternal orderByColumn;
 
793
        orderByColumn.setColumnByNameOrNumber( *$1 );
 
794
        $$->append( orderByColumn );
 
795
        delete $1;
 
796
}
 
797
| OrderByColumnId OrderByOption
 
798
{
 
799
        KexiDBDbg << "ORDER BY IDENTIFIER OrderByOption";
 
800
        $$ = new OrderByColumnInternal::List;
 
801
        OrderByColumnInternal orderByColumn;
 
802
        orderByColumn.setColumnByNameOrNumber( *$1 );
 
803
        orderByColumn.ascending = $2;
 
804
        $$->append( orderByColumn );
 
805
        delete $1;
 
806
}
 
807
| OrderByColumnId ',' OrderByClause
 
808
{
 
809
        $$ = $3;
 
810
        OrderByColumnInternal orderByColumn;
 
811
        orderByColumn.setColumnByNameOrNumber( *$1 );
 
812
        $$->append( orderByColumn );
 
813
        delete $1;
 
814
}
 
815
| OrderByColumnId OrderByOption ',' OrderByClause
 
816
{
 
817
        $$ = $4;
 
818
        OrderByColumnInternal orderByColumn;
 
819
        orderByColumn.setColumnByNameOrNumber( *$1 );
 
820
        orderByColumn.ascending = $2;
 
821
        $$->append( orderByColumn );
 
822
        delete $1;
 
823
}
 
824
;
 
825
 
 
826
OrderByColumnId:
 
827
IDENTIFIER
 
828
{
 
829
        $$ = new QVariant( *$1 );
 
830
        KexiDBDbg << "OrderByColumnId: " << *$$;
 
831
        delete $1;
 
832
}
 
833
| IDENTIFIER '.' IDENTIFIER
 
834
{
 
835
        $$ = new QVariant( *$1 + "." + *$3 );
 
836
        KexiDBDbg << "OrderByColumnId: " << *$$;
 
837
        delete $1;
 
838
        delete $3;
 
839
}
 
840
| INTEGER_CONST
 
841
{
 
842
        $$ = new QVariant($1);
 
843
        KexiDBDbg << "OrderByColumnId: " << *$$;
 
844
}
 
845
 
 
846
OrderByOption:
 
847
ASC
 
848
{
 
849
        $$ = true;
 
850
}
 
851
| DESC
 
852
{
 
853
        $$ = false;
 
854
}
 
855
;
 
856
 
 
857
aExpr:
 
858
aExpr2
 
859
;
 
860
 
 
861
/* --- binary logical --- */
 
862
aExpr2:
 
863
aExpr3 AND aExpr2
 
864
{
 
865
//      KexiDBDbg << "AND " << $3.debugString();
 
866
        $$ = new BinaryExpr( KexiDBExpr_Logical, $1, AND, $3 );
 
867
}
 
868
| aExpr3 OR aExpr2
 
869
{
 
870
        $$ = new BinaryExpr( KexiDBExpr_Logical, $1, OR, $3 );
 
871
}
 
872
| aExpr3 XOR aExpr2
 
873
{
 
874
        $$ = new BinaryExpr( KexiDBExpr_Arithm, $1, XOR, $3 );
 
875
}
 
876
|
 
877
aExpr3
 
878
;
 
879
 
 
880
/* relational op precedence */
 
881
aExpr3:
 
882
aExpr4 '>' %prec GREATER_OR_EQUAL aExpr3
 
883
{
 
884
        $$ = new BinaryExpr(KexiDBExpr_Relational, $1, '>', $3);
 
885
}
 
886
| aExpr4 GREATER_OR_EQUAL aExpr3
 
887
{
 
888
        $$ = new BinaryExpr(KexiDBExpr_Relational, $1, GREATER_OR_EQUAL, $3);
 
889
}
 
890
| aExpr4 '<' %prec LESS_OR_EQUAL aExpr3
 
891
{
 
892
        $$ = new BinaryExpr(KexiDBExpr_Relational, $1, '<', $3);
 
893
}
 
894
| aExpr4 LESS_OR_EQUAL aExpr3
 
895
{
 
896
        $$ = new BinaryExpr(KexiDBExpr_Relational, $1, LESS_OR_EQUAL, $3);
 
897
}
 
898
| aExpr4 '=' aExpr3
 
899
{
 
900
        $$ = new BinaryExpr(KexiDBExpr_Relational, $1, '=', $3);
 
901
}
 
902
|
 
903
aExpr4
 
904
;
 
905
 
 
906
/* relational (equality) op precedence */
 
907
aExpr4:
 
908
aExpr5 NOT_EQUAL aExpr4
 
909
{
 
910
        $$ = new BinaryExpr(KexiDBExpr_Relational, $1, NOT_EQUAL, $3);
 
911
}
 
912
|
 
913
aExpr5 NOT_EQUAL2 aExpr4
 
914
{
 
915
        $$ = new BinaryExpr(KexiDBExpr_Relational, $1, NOT_EQUAL2, $3);
 
916
}
 
917
| aExpr5 LIKE aExpr4
 
918
{
 
919
        $$ = new BinaryExpr(KexiDBExpr_Relational, $1, LIKE, $3);
 
920
}
 
921
| aExpr5 SQL_IN aExpr4
 
922
{
 
923
        $$ = new BinaryExpr(KexiDBExpr_Relational, $1, SQL_IN, $3);
 
924
}
 
925
| aExpr5 SIMILAR_TO aExpr4
 
926
{
 
927
        $$ = new BinaryExpr(KexiDBExpr_Relational, $1, SIMILAR_TO, $3);
 
928
}
 
929
| aExpr5 NOT_SIMILAR_TO aExpr4
 
930
{
 
931
        $$ = new BinaryExpr(KexiDBExpr_Relational, $1, NOT_SIMILAR_TO, $3);
 
932
}
 
933
|
 
934
aExpr5
 
935
;
 
936
 
 
937
/* --- unary logical right --- */
 
938
aExpr5:
 
939
aExpr5 SQL_IS_NULL
 
940
{
 
941
        $$ = new UnaryExpr( SQL_IS_NULL, $1 );
 
942
}
 
943
| aExpr5 SQL_IS_NOT_NULL
 
944
{
 
945
        $$ = new UnaryExpr( SQL_IS_NOT_NULL, $1 );
 
946
}
 
947
|
 
948
aExpr6
 
949
;
 
950
 
 
951
/* arithm. lowest precedence */
 
952
aExpr6:
 
953
aExpr7 BITWISE_SHIFT_LEFT aExpr6
 
954
{
 
955
        $$ = new BinaryExpr(KexiDBExpr_Arithm, $1, BITWISE_SHIFT_LEFT, $3);
 
956
}
 
957
| aExpr7 BITWISE_SHIFT_RIGHT aExpr6
 
958
{
 
959
        $$ = new BinaryExpr(KexiDBExpr_Arithm, $1, BITWISE_SHIFT_RIGHT, $3);
 
960
}
 
961
|
 
962
aExpr7
 
963
;
 
964
 
 
965
/* arithm. lower precedence */
 
966
aExpr7:
 
967
aExpr8 '+' aExpr7
 
968
{
 
969
        $$ = new BinaryExpr(KexiDBExpr_Arithm, $1, '+', $3);
 
970
        $$->debug();
 
971
}
 
972
| aExpr8 '-' %prec UMINUS aExpr7
 
973
{
 
974
        $$ = new BinaryExpr(KexiDBExpr_Arithm, $1, '-', $3);
 
975
}
 
976
| aExpr8 '&' aExpr7
 
977
{
 
978
        $$ = new BinaryExpr(KexiDBExpr_Arithm, $1, '&', $3);
 
979
}
 
980
| aExpr8 '|' aExpr7
 
981
{
 
982
        $$ = new BinaryExpr(KexiDBExpr_Arithm, $1, '|', $3);
 
983
}
 
984
|
 
985
aExpr8
 
986
;
 
987
 
 
988
/* arithm. higher precedence */
 
989
aExpr8:
 
990
aExpr9 '/' aExpr8
 
991
{
 
992
        $$ = new BinaryExpr(KexiDBExpr_Arithm, $1, '/', $3);
 
993
}
 
994
| aExpr9 '*' aExpr8
 
995
{
 
996
        $$ = new BinaryExpr(KexiDBExpr_Arithm, $1, '*', $3);
 
997
}
 
998
| aExpr9 '%' aExpr8
 
999
{
 
1000
        $$ = new BinaryExpr(KexiDBExpr_Arithm, $1, '%', $3);
 
1001
}
 
1002
|
 
1003
aExpr9
 
1004
;
 
1005
 
 
1006
/* parenthesis, unary operators, and terminals precedence */
 
1007
aExpr9:
 
1008
/* --- unary logical left --- */
 
1009
'-' aExpr9
 
1010
{
 
1011
        $$ = new UnaryExpr( '-', $2 );
 
1012
}
 
1013
| '+' aExpr9
 
1014
{
 
1015
        $$ = new UnaryExpr( '+', $2 );
 
1016
}
 
1017
| '~' aExpr9
 
1018
{
 
1019
        $$ = new UnaryExpr( '~', $2 );
 
1020
}
 
1021
| NOT aExpr9
 
1022
{
 
1023
        $$ = new UnaryExpr( NOT, $2 );
 
1024
}
 
1025
| IDENTIFIER
 
1026
{
 
1027
        $$ = new VariableExpr( *$1 );
 
1028
        
 
1029
//TODO: simplify this later if that's 'only one field name' expression
 
1030
        KexiDBDbg << "  + identifier: " << *$1;
 
1031
        delete $1;
 
1032
}
 
1033
| QUERY_PARAMETER
 
1034
{
 
1035
        $$ = new QueryParameterExpr( *$1 );
 
1036
        KexiDBDbg << "  + query parameter: " << $$->debugString();
 
1037
        delete $1;
 
1038
}
 
1039
| IDENTIFIER aExprList
 
1040
{
 
1041
        KexiDBDbg << "  + function: " << *$1 << "(" << $2->debugString() << ")";
 
1042
        $$ = new FunctionExpr(*$1, $2);
 
1043
        delete $1;
 
1044
}
 
1045
/*TODO: shall we also support db name? */
 
1046
| IDENTIFIER '.' IDENTIFIER
 
1047
{
 
1048
        $$ = new VariableExpr( *$1 + "." + *$3 );
 
1049
        KexiDBDbg << "  + identifier.identifier: " << *$1 << "." << *$3;
 
1050
        delete $1;
 
1051
        delete $3;
 
1052
}
 
1053
| SQL_NULL
 
1054
{
 
1055
        $$ = new ConstExpr( SQL_NULL, QVariant() );
 
1056
        KexiDBDbg << "  + NULL";
 
1057
//      $$ = new Field();
 
1058
        //$$->setName(QString::null);
 
1059
}
 
1060
| CHARACTER_STRING_LITERAL
 
1061
{
 
1062
        $$ = new ConstExpr( CHARACTER_STRING_LITERAL, *$1 );
 
1063
        KexiDBDbg << "  + constant " << $1;
 
1064
        delete $1;
 
1065
}
 
1066
| INTEGER_CONST
 
1067
{
 
1068
        QVariant val;
 
1069
        if ($1 <= INT_MAX && $1 >= INT_MIN)
 
1070
                val = (int)$1;
 
1071
        else if ($1 <= UINT_MAX && $1 >= 0)
 
1072
                val = (uint)$1;
 
1073
        else if ($1 <= LLONG_MAX && $1 >= LLONG_MIN)
 
1074
                val = (qint64)$1;
 
1075
 
 
1076
//      if ($1 < ULLONG_MAX)
 
1077
//              val = (quint64)$1;
 
1078
//TODO ok?
 
1079
 
 
1080
        $$ = new ConstExpr( INTEGER_CONST, val );
 
1081
        KexiDBDbg << "  + int constant: " << val.toString();
 
1082
}
 
1083
| REAL_CONST
 
1084
{
 
1085
        $$ = new ConstExpr( REAL_CONST, QPoint( $1.integer, $1.fractional ) );
 
1086
        KexiDBDbg << "  + real constant: " << $1.integer << "." << $1.fractional;
 
1087
}
 
1088
|
 
1089
aExpr10
 
1090
;
 
1091
 
 
1092
 
 
1093
aExpr10:
 
1094
'(' aExpr ')'
 
1095
{
 
1096
        KexiDBDbg << "(expr)";
 
1097
        $$ = new UnaryExpr('(', $2);
 
1098
}
 
1099
;
 
1100
 
 
1101
aExprList:
 
1102
'(' aExprList2 ')'
 
1103
{
 
1104
//      $$ = new NArgExpr(0, 0);
 
1105
//      $$->add( $1 );
 
1106
//      $$->add( $3 );
 
1107
        $$ = $2;
 
1108
}
 
1109
;
 
1110
 
 
1111
aExprList2:
 
1112
aExpr ',' aExprList2
 
1113
{
 
1114
        $$ = $3;
 
1115
        $$->prepend( $1 );
 
1116
}
 
1117
| aExpr ',' aExpr
 
1118
{
 
1119
        $$ = new NArgExpr(0, 0);
 
1120
        $$->add( $1 );
 
1121
        $$->add( $3 );
 
1122
}
 
1123
;
 
1124
 
 
1125
Tables:
 
1126
FROM FlatTableList
 
1127
{
 
1128
        $$ = $2;
 
1129
}
 
1130
/*
 
1131
| Tables LEFT JOIN IDENTIFIER SQL_ON ColExpression
 
1132
{
 
1133
        KexiDBDbg << "LEFT JOIN: '" << *$4 << "' ON " << $6;
 
1134
        addTable($4->toQString());
 
1135
        delete $4;
 
1136
}
 
1137
| Tables LEFT OUTER JOIN IDENTIFIER SQL_ON ColExpression
 
1138
{
 
1139
        KexiDBDbg << "LEFT OUTER JOIN: '" << $5 << "' ON " << $7;
 
1140
        addTable($5);
 
1141
}
 
1142
| Tables INNER JOIN IDENTIFIER SQL_ON ColExpression
 
1143
{
 
1144
        KexiDBDbg << "INNER JOIN: '" << *$4 << "' ON " << $6;
 
1145
        addTable($4->toQString());
 
1146
        delete $4;
 
1147
}
 
1148
| Tables RIGHT JOIN IDENTIFIER SQL_ON ColExpression
 
1149
{
 
1150
        KexiDBDbg << "RIGHT JOIN: '" << *$4 << "' ON " << $6;
 
1151
        addTable(*$4);
 
1152
        delete $4;
 
1153
}
 
1154
| Tables RIGHT OUTER JOIN IDENTIFIER SQL_ON ColExpression
 
1155
{
 
1156
        KexiDBDbg << "RIGHT OUTER JOIN: '" << *$5 << "' ON " << $7;
 
1157
        addTable($5->toQString());
 
1158
        delete $5;
 
1159
}*/
 
1160
;
 
1161
 
 
1162
/*
 
1163
FlatTableList:
 
1164
aFlatTableList
 
1165
{
 
1166
        $$
 
1167
}
 
1168
;*/
 
1169
 
 
1170
FlatTableList:
 
1171
FlatTableList ',' FlatTable
 
1172
{
 
1173
        $$ = $1;
 
1174
        $$->add($3);
 
1175
}
 
1176
|FlatTable
 
1177
{
 
1178
        $$ = new NArgExpr(KexiDBExpr_TableList, IDENTIFIER); //ok?
 
1179
        $$->add($1);
 
1180
}
 
1181
;
 
1182
 
 
1183
FlatTable:
 
1184
IDENTIFIER
 
1185
{
 
1186
        KexiDBDbg << "FROM: '" << *$1 << "'";
 
1187
        $$ = new VariableExpr(*$1);
 
1188
 
 
1189
        /*
 
1190
//TODO: this isn't ok for more tables:
 
1191
        Field::ListIterator it = parser->select()->fieldsIterator();
 
1192
        for(Field *item; (item = it.current()); ++it)
 
1193
        {
 
1194
                if(item->table() == dummy)
 
1195
                {
 
1196
                        item->setTable(schema);
 
1197
                }
 
1198
 
 
1199
                if(item->table() && !item->isQueryAsterisk())
 
1200
                {
 
1201
                        Field *f = item->table()->field(item->name());
 
1202
                        if(!f)
 
1203
                        {
 
1204
                                ParserError err(i18n("Field List Error"), i18n("Unknown column '%1' in table '%2'",item->name(),schema->name()), ctoken, current);
 
1205
                                parser->setError(err);
 
1206
                                yyerror("fieldlisterror");
 
1207
                        }       
 
1208
                }
 
1209
        }*/
 
1210
        delete $1;
 
1211
}
 
1212
| IDENTIFIER IDENTIFIER
 
1213
{
 
1214
        //table + alias
 
1215
        $$ = new BinaryExpr(
 
1216
                KexiDBExpr_SpecialBinary, 
 
1217
                new VariableExpr(*$1), 0,
 
1218
                new VariableExpr(*$2)
 
1219
        );
 
1220
        delete $1;
 
1221
        delete $2;
 
1222
}
 
1223
| IDENTIFIER AS IDENTIFIER
 
1224
{
 
1225
        //table + alias
 
1226
        $$ = new BinaryExpr(
 
1227
                KexiDBExpr_SpecialBinary,
 
1228
                new VariableExpr(*$1), AS,
 
1229
                new VariableExpr(*$3)
 
1230
        );
 
1231
        delete $1;
 
1232
        delete $3;
 
1233
}
 
1234
;
 
1235
 
 
1236
 
 
1237
 
 
1238
ColViews:
 
1239
ColViews ',' ColItem
 
1240
{
 
1241
        $$ = $1;
 
1242
        $$->add( $3 );
 
1243
        KexiDBDbg << "ColViews: ColViews , ColItem";
 
1244
}
 
1245
|ColItem
 
1246
{
 
1247
        $$ = new NArgExpr(0,0);
 
1248
        $$->add( $1 );
 
1249
        KexiDBDbg << "ColViews: ColItem";
 
1250
}
 
1251
;
 
1252
 
 
1253
ColItem:
 
1254
ColExpression
 
1255
{
 
1256
//      $$ = new Field();
 
1257
//      dummy->addField($$);
 
1258
//      $$->setExpression( $1 );
 
1259
//      parser->select()->addField($$);
 
1260
        $$ = $1;
 
1261
        KexiDBDbg << " added column expr: '" << $1->debugString() << "'";
 
1262
}
 
1263
| ColWildCard
 
1264
{
 
1265
        $$ = $1;
 
1266
        KexiDBDbg << " added column wildcard: '" << $1->debugString() << "'";
 
1267
}
 
1268
| ColExpression AS IDENTIFIER
 
1269
{
 
1270
        $$ = new BinaryExpr(
 
1271
                KexiDBExpr_SpecialBinary, $1, AS,
 
1272
                new VariableExpr(*$3)
 
1273
        );
 
1274
        KexiDBDbg << " added column expr: " << $$->debugString();
 
1275
        delete $3;
 
1276
}
 
1277
| ColExpression IDENTIFIER
 
1278
{
 
1279
        $$ = new BinaryExpr(
 
1280
                KexiDBExpr_SpecialBinary, $1, 0, 
 
1281
                new VariableExpr(*$2)
 
1282
        );
 
1283
        KexiDBDbg << " added column expr: " << $$->debugString();
 
1284
        delete $2;
 
1285
}
 
1286
;
 
1287
 
 
1288
ColExpression:
 
1289
aExpr
 
1290
{
 
1291
        $$ = $1;
 
1292
}
 
1293
/* HANDLED BY 'IDENTIFIER aExprList'
 
1294
| IDENTIFIER '(' ColViews ')'
 
1295
{
 
1296
        $$ = new FunctionExpr( $1, $3 );
 
1297
}*/
 
1298
/*
 
1299
| SUM '(' ColExpression ')'
 
1300
{
 
1301
        FunctionExpr(
 
1302
//      $$ = new AggregationExpr( SUM,  );
 
1303
//TODO
 
1304
//      $$->setName("SUM(" + $3->name() + ")");
 
1305
//wait  $$->containsGroupingAggregate(true);
 
1306
//wait  parser->select()->grouped(true);
 
1307
}
 
1308
| SQL_MIN '(' ColExpression ')'
 
1309
{
 
1310
        $$ = $3;
 
1311
//TODO
 
1312
//      $$->setName("MIN(" + $3->name() + ")");
 
1313
//wait  $$->containsGroupingAggregate(true);
 
1314
//wait  parser->select()->grouped(true);
 
1315
}
 
1316
| SQL_MAX '(' ColExpression ')'
 
1317
{
 
1318
        $$ = $3;
 
1319
//TODO
 
1320
//      $$->setName("MAX(" + $3->name() + ")");
 
1321
//wait  $$->containsGroupingAggregate(true);
 
1322
//wait  parser->select()->grouped(true);
 
1323
}
 
1324
| AVG '(' ColExpression ')'
 
1325
{
 
1326
        $$ = $3;
 
1327
//TODO
 
1328
//      $$->setName("AVG(" + $3->name() + ")");
 
1329
//wait  $$->containsGroupingAggregate(true);
 
1330
//wait  parser->select()->grouped(true);
 
1331
}*/
 
1332
//?
 
1333
| DISTINCT '(' ColExpression ')' 
 
1334
{
 
1335
        $$ = $3;
 
1336
//TODO
 
1337
//      $$->setName("DISTINCT(" + $3->name() + ")");
 
1338
}
 
1339
;
 
1340
 
 
1341
ColWildCard:
 
1342
'*'
 
1343
{
 
1344
        $$ = new VariableExpr("*");
 
1345
        KexiDBDbg << "all columns";
 
1346
 
 
1347
//      QueryAsterisk *ast = new QueryAsterisk(parser->select(), dummy);
 
1348
//      parser->select()->addAsterisk(ast);
 
1349
//      requiresTable = true;
 
1350
}
 
1351
| IDENTIFIER '.' '*'
 
1352
{
 
1353
        QString s( *$1 );
 
1354
        s += ".*";
 
1355
        $$ = new VariableExpr(s);
 
1356
        KexiDBDbg << "  + all columns from " << s;
 
1357
        delete $1;
 
1358
}
 
1359
/*| ERROR_DIGIT_BEFORE_IDENTIFIER
 
1360
{
 
1361
        $$ = new VariableExpr($1);
 
1362
        KexiDBDbg << "  Invalid identifier! " << $1;
 
1363
        setError(i18n("Invalid identifier \"%1\"",$1));
 
1364
}*/
 
1365
;
 
1366
 
 
1367
%%
 
1368