hunt.sql.dialect.postgresql.visitor.PGOutputVisitor source code

1 /*
2  * Copyright 2015-2018 HuntLabs.cn
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 module hunt.sql.dialect.postgresql.visitor.PGOutputVisitor;
17 
18 import hunt.sql.ast;
19 import hunt.sql.ast.expr;
20 import hunt.sql.ast.statement;
21 // import hunt.sql.dialect.oracle.ast.OracleDataTypeIntervalDay;
22 // import hunt.sql.dialect.oracle.ast.OracleDataTypeIntervalYear;
23 // import hunt.sql.dialect.oracle.ast.clause;
24 // import hunt.sql.dialect.oracle.ast.expr;
25 // import hunt.sql.dialect.oracle.ast.stmt;
26 // import hunt.sql.dialect.oracle.parser.OracleFunctionDataType;
27 // import hunt.sql.dialect.oracle.parser.OracleProcedureDataType;
28 // import hunt.sql.dialect.oracle.visitor.OracleASTVisitor;
29 import hunt.sql.dialect.postgresql.ast.expr.PGBoxExpr;
30 import hunt.sql.dialect.postgresql.ast.expr.PGCidrExpr;
31 import hunt.sql.dialect.postgresql.ast.expr.PGCircleExpr;
32 import hunt.sql.dialect.postgresql.ast.expr.PGExtractExpr;
33 import hunt.sql.dialect.postgresql.ast.expr.PGInetExpr;
34 import hunt.sql.dialect.postgresql.ast.expr.PGLineSegmentsExpr;
35 import hunt.sql.dialect.postgresql.ast.expr.PGMacAddrExpr;
36 import hunt.sql.dialect.postgresql.ast.expr.PGPointExpr;
37 import hunt.sql.dialect.postgresql.ast.expr.PGPolygonExpr;
38 import hunt.sql.dialect.postgresql.ast.expr.PGTypeCastExpr;
39 import hunt.sql.dialect.postgresql.ast.stmt;
40 import hunt.sql.dialect.postgresql.ast.stmt.PGSelectQueryBlock;
41 // import hunt.sql.dialect.postgresql.ast.stmt.PGSelectQueryBlock.FetchClause;
42 // import hunt.sql.dialect.postgresql.ast.stmt.PGSelectQueryBlock.ForClause;
43 // import hunt.sql.dialect.postgresql.ast.stmt.PGSelectQueryBlock.WindowClause;
44 import hunt.sql.visitor.SQLASTOutputVisitor;
45 import hunt.sql.util.FnvHash;
46 import hunt.sql.util.DBType;
47 import hunt.sql.dialect.postgresql.visitor.PGASTVisitor;
48 
49 import hunt.Byte;
50 import hunt.collection;
51 import hunt.logging;
52 import hunt.String;
53 import hunt.util.Appendable;
54 import hunt.util.Common;
55 import hunt.text;
56 
57 import std.array;
58 import std.format;
59 import std.uni;
60 import std.algorithm.searching;
61 
62 public class PGOutputVisitor : SQLASTOutputVisitor , PGASTVisitor//, OracleASTVisitor 
63 {
64     alias visit = SQLASTOutputVisitor.visit;
65     alias endVisit = SQLASTOutputVisitor.endVisit; 
66 
67     public this(Appendable appender){
68         super(appender);
69         this.dbType = DBType.POSTGRESQL.name;
70     }
71 
72     public this(Appendable appender, bool parameterized){
73         super(appender, parameterized);
74         this.dbType = DBType.POSTGRESQL.name;
75     }
76 
77     override
78     public void endVisit(PGSelectQueryBlock.WindowClause x) {
79 
80     }
81 
82     override
83     public bool visit(PGSelectQueryBlock.WindowClause x) {
84         print0(ucase ? "WINDOW " : "window ");
85         x.getName().accept(this);
86         print0(ucase ? " AS " : " as ");
87         for (int i = 0; i < x.getDefinition().size(); ++i) {
88             if (i != 0) {
89                 println(", ");
90             }
91             print('(');
92             x.getDefinition().get(i).accept(this);
93             print(')');
94         }
95         return false;
96     }
97 
98     override
99     public void endVisit(PGSelectQueryBlock.FetchClause x) {
100 
101     }
102 
103     override
104     public bool visit(PGSelectQueryBlock.FetchClause x) {
105         print0(ucase ? "FETCH " : "fetch ");
106         if (PGSelectQueryBlock.FetchClause.Option.FIRST == (x.getOption())) {
107             print0(ucase ? "FIRST " : "first ");
108         } else if (PGSelectQueryBlock.FetchClause.Option.NEXT == (x.getOption())) {
109             print0(ucase ? "NEXT " : "next ");
110         }
111         x.getCount().accept(this);
112         print0(ucase ? " ROWS ONLY" : " rows only");
113         return false;
114     }
115 
116     override
117     public void endVisit(PGSelectQueryBlock.ForClause x) {
118 
119     }
120 
121     override
122     public bool visit(PGSelectQueryBlock.ForClause x) {
123         print0(ucase ? "FOR " : "for ");
124         if (PGSelectQueryBlock.ForClause.Option.UPDATE == (x.getOption())) {
125             print0(ucase ? "UPDATE " : "update ");
126         } else if (PGSelectQueryBlock.ForClause.Option.SHARE == (x.getOption())) {
127             print0(ucase ? "SHARE " : "share ");
128         }
129 
130         if (x.getOf().size() > 0) {
131             for (int i = 0; i < x.getOf().size(); ++i) {
132                 if (i != 0) {
133                     println(", ");
134                 }
135                 x.getOf().get(i).accept(this);
136             }
137         }
138 
139         if (x.isNoWait()) {
140             print0(ucase ? " NOWAIT" : " nowait");
141         }
142 
143         return false;
144     }
145 
146 
147     public bool visit(PGSelectQueryBlock x) {
148         print0(ucase ? "SELECT " : "select ");
149 
150         if (SQLSetQuantifier.ALL == x.getDistionOption()) {
151             print0(ucase ? "ALL " : "all ");
152         } else if (SQLSetQuantifier.DISTINCT == x.getDistionOption()) {
153             print0(ucase ? "DISTINCT " : "distinct ");
154 
155             if (x.getDistinctOn() !is null && x.getDistinctOn().size() > 0) {
156                 print0(ucase ? "ON " : "on ");
157                 printAndAccept!SQLExpr((x.getDistinctOn()), ", ");
158             }
159         }
160 
161         printSelectList(x.getSelectList());
162 
163         if (x.getInto() !is null) {
164             println();
165             if (x.getIntoOption().name.length != 0) {
166                 print0(x.getIntoOption().name());
167                 print(' ');
168             }
169 
170             print0(ucase ? "INTO " : "into ");
171             x.getInto().accept(this);
172         }
173 
174         if (x.getFrom() !is null) {
175             println();
176             print0(ucase ? "FROM " : "from ");
177             x.getFrom().accept(this);
178         }
179 
180         if (x.getWhere() !is null) {
181             println();
182             print0(ucase ? "WHERE " : "where ");
183             x.getWhere().accept(this);
184         }
185 
186         if (x.getGroupBy() !is null) {
187             println();
188             x.getGroupBy().accept(this);
189         }
190 
191         if (x.getWindow() !is null) {
192             println();
193             x.getWindow().accept(this);
194         }
195 
196         if (x.getOrderBy() !is null) {
197             println();
198             x.getOrderBy().accept(this);
199         }
200 
201         if (x.getLimit() !is null) {
202             println();
203             x.getLimit().accept(this);
204         }
205 
206         if (x.getFetch() !is null) {
207             println();
208             x.getFetch().accept(this);
209         }
210 
211         if (x.getForClause() !is null) {
212             println();
213             x.getForClause().accept(this);
214         }
215 
216         return false;
217     }
218 
219     override
220     public bool visit(SQLTruncateStatement x) {
221         print0(ucase ? "TRUNCATE TABLE " : "truncate table ");
222         if (x.isOnly()) {
223             print0(ucase ? "ONLY " : "only ");
224         }
225 
226         printlnAndAccept!(SQLExprTableSource)((x.getTableSources()), ", ");
227 
228         if (x.getRestartIdentity() !is null) {
229             if (x.getRestartIdentity().booleanValue()) {
230                 print0(ucase ? " RESTART IDENTITY" : " restart identity");
231             } else {
232                 print0(ucase ? " CONTINUE IDENTITY" : " continue identity");
233             }
234         }
235 
236         if (x.getCascade() !is null) {
237             if (x.getCascade().booleanValue()) {
238                 print0(ucase ? " CASCADE" : " cascade");
239             } else {
240                 print0(ucase ? " RESTRICT"  : " restrict");
241             }
242         }
243         return false;
244     }
245 
246     override
247     public void endVisit(PGDeleteStatement x) {
248 
249     }
250 
251     override
252     public bool visit(PGDeleteStatement x) {
253         if (x.getWith() !is null) {
254             x.getWith().accept(this);
255             println();
256         }
257 
258         print0(ucase ? "DELETE FROM " : "delete from ");
259 
260         if (x.isOnly()) {
261             print0(ucase ? "ONLY " : "only ");
262         }
263 
264         printTableSourceExpr(x.getTableName());
265 
266         if (x.getAlias() !is null) {
267             print0(ucase ? " AS " : " as ");
268             print0(x.getAlias());
269         }
270 
271         SQLTableSource using = x.getUsing();
272         if (using !is null) {
273             println();
274             print0(ucase ? "USING " : "using ");
275             using.accept(this);
276         }
277 
278         if (x.getWhere() !is null) {
279             println();
280             print0(ucase ? "WHERE " : "where ");
281             this.indentCount++;
282             x.getWhere().accept(this);
283             this.indentCount--;
284         }
285 
286         if (x.isReturning()) {
287             println();
288             print0(ucase ? "RETURNING *" : "returning *");
289         }
290 
291         return false;
292     }
293 
294     override
295     public void endVisit(PGInsertStatement x) {
296 
297     }
298 
299     override
300     public bool visit(PGInsertStatement x) {
301         if (x.getWith() !is null) {
302             x.getWith().accept(this);
303             println();
304         }
305 
306         print0(ucase ? "INSERT INTO " : "insert into ");
307 
308         x.getTableSource().accept(this);
309 
310         printInsertColumns(x.getColumns());
311 
312         if (x.getValues() !is null) {
313             println();
314             print0(ucase ? "VALUES " : "values ");
315             printlnAndAccept!(ValuesClause)((x.getValuesList()), ", ");
316         } else {
317             if (x.getQuery() !is null) {
318                 println();
319                 x.getQuery().accept(this);
320             }
321         }
322 
323         List!(SQLExpr) onConflictTarget = x.getOnConflictTarget();
324         List!(SQLUpdateSetItem) onConflictUpdateSetItems = x.getOnConflictUpdateSetItems();
325         bool onConflictDoNothing = x.isOnConflictDoNothing();
326 
327         if (onConflictDoNothing
328                 || (onConflictTarget !is null && onConflictTarget.size() > 0)
329                 || (onConflictUpdateSetItems !is null && onConflictUpdateSetItems.size() > 0)) {
330             println();
331             print0(ucase ? "ON CONFLICT" : "on conflict");
332 
333             if ((onConflictTarget !is null && onConflictTarget.size() > 0)) {
334                 print0(" (");
335                 printAndAccept!SQLExpr((onConflictTarget), ", ");
336                 print(')');
337             }
338 
339             SQLName onConflictConstraint = x.getOnConflictConstraint();
340             if (onConflictConstraint !is null) {
341                 print0(ucase ? " ON CONSTRAINT " : " on constraint ");
342                 printExpr(onConflictConstraint);
343             }
344 
345             SQLExpr onConflictWhere = x.getOnConflictWhere();
346             if (onConflictWhere !is null) {
347                 print0(ucase ? " WHERE " : " where ");
348                 printExpr(onConflictWhere);
349             }
350 
351             if (onConflictDoNothing) {
352                 print0(ucase ? " DO NOTHING" : " do nothing");
353             } else if ((onConflictUpdateSetItems !is null && onConflictUpdateSetItems.size() > 0)) {
354                 print0(ucase ? " UPDATE SET " : " update set ");
355                 printAndAccept!SQLUpdateSetItem((onConflictUpdateSetItems), ", ");
356             }
357         }
358 
359         if (x.getReturning() !is null) {
360             println();
361             print0(ucase ? "RETURNING " : "returning ");
362             x.getReturning().accept(this);
363         }
364 
365         return false;
366     }
367 
368     override
369     public void endVisit(PGSelectStatement x) {
370 
371     }
372 
373     override
374     public bool visit(PGSelectStatement x) {
375         return visit(cast(SQLSelectStatement) x);
376     }
377 
378     override
379     public void endVisit(PGUpdateStatement x) {
380 
381     }
382 
383     override
384     public bool visit(PGUpdateStatement x) {
385         SQLWithSubqueryClause with_p = x.getWith();
386         if (with_p !is null) {
387             visit(with_p);
388             println();
389         }
390 
391         print0(ucase ? "UPDATE " : "update ");
392 
393         if (x.isOnly()) {
394             print0(ucase ? "ONLY " : "only ");
395         }
396 
397         printTableSource(x.getTableSource());
398 
399         println();
400         print0(ucase ? "SET " : "set ");
401         for (int i = 0, size = x.getItems().size(); i < size; ++i) {
402             if (i != 0) {
403                 print0(", ");
404             }
405             SQLUpdateSetItem item = x.getItems().get(i);
406             visit(item);
407         }
408 
409         SQLTableSource from = x.getFrom();
410         if (from !is null) {
411             println();
412             print0(ucase ? "FROM " : "from ");
413             printTableSource(from);
414         }
415 
416         SQLExpr where = x.getWhere();
417         if (where !is null) {
418             println();
419             indentCount++;
420             print0(ucase ? "WHERE " : "where ");
421             printExpr(where);
422             indentCount--;
423         }
424 
425         List!(SQLExpr) returning = x.getReturning();
426         if (returning.size() > 0) {
427             println();
428             print0(ucase ? "RETURNING " : "returning ");
429             printAndAccept!SQLExpr((returning), ", ");
430         }
431 
432         return false;
433     }
434 
435     override
436     public void endVisit(PGSelectQueryBlock x) {
437 
438     }
439 
440     override
441     public bool visit(PGFunctionTableSource x) {
442         x.getExpr().accept(this);
443 
444         if (x.getAlias() !is null) {
445             print0(ucase ? " AS " : " as ");
446             print0(x.getAlias());
447         }
448 
449         if (x.getParameters().size() > 0) {
450             print('(');
451             printAndAccept!SQLParameter((x.getParameters()), ", ");
452             print(')');
453         }
454 
455         return false;
456     }
457 
458     override
459     public void endVisit(PGFunctionTableSource x) {
460 
461     }
462 
463     override
464     public void endVisit(PGTypeCastExpr x) {
465         
466     }
467 
468     override
469     public bool visit(PGTypeCastExpr x) {
470         SQLExpr expr = x.getExpr();
471         SQLDataType dataType = x.getDataType();
472 
473         if (dataType.nameHashCode64() == FnvHash.Constants.VARBIT) {
474             dataType.accept(this);
475             print(' ');
476             printExpr(expr);
477             return false;
478         }
479 
480         if (expr !is null) {
481             if (cast(SQLBinaryOpExpr)(expr) !is null) {
482                 print('(');
483                 expr.accept(this);
484                 print(')');
485             } else if (cast(PGTypeCastExpr)(expr) !is null && dataType.getArguments().size() == 0) {
486                 dataType.accept(this);
487                 print('(');
488                 visit(cast(PGTypeCastExpr) expr);
489                 print(')');
490                 return false;
491             } else {
492                 expr.accept(this);
493             }
494         }
495         print0("::");
496         dataType.accept(this);
497         return false;
498     }
499 
500     override
501     public void endVisit(PGValuesQuery x) {
502         
503     }
504 
505     override
506     public bool visit(PGValuesQuery x) {
507         print0(ucase ? "VALUES(" : "values(");
508         printAndAccept!SQLExpr((x.getValues()), ", ");
509         print(')');
510         return false;
511     }
512     
513     override
514     public void endVisit(PGExtractExpr x) {
515         
516     }
517     
518     override
519     public bool visit(PGExtractExpr x) {
520         print0(ucase ? "EXTRACT (" : "extract (");
521         print0(x.getField().name());
522         print0(ucase ? " FROM " : " from ");
523         x.getSource().accept(this);
524         print(')');
525         return false;
526     }
527     
528     override
529     public bool visit(PGBoxExpr x) {
530         print0(ucase ? "BOX " : "box ");
531         x.getValue().accept(this);
532         return false;
533     }
534 
535     override
536     public void endVisit(PGBoxExpr x) {
537         
538     }
539     
540     override
541     public bool visit(PGPointExpr x) {
542         print0(ucase ? "POINT " : "point ");
543         x.getValue().accept(this);
544         return false;
545     }
546     
547     override
548     public void endVisit(PGPointExpr x) {
549         
550     }
551     
552     override
553     public bool visit(PGMacAddrExpr x) {
554         print0("macaddr ");
555         x.getValue().accept(this);
556         return false;
557     }
558     
559     override
560     public void endVisit(PGMacAddrExpr x) {
561         
562     }
563     
564     override
565     public bool visit(PGInetExpr x) {
566         print0("inet ");
567         x.getValue().accept(this);
568         return false;
569     }
570     
571     override
572     public void endVisit(PGInetExpr x) {
573         
574     }
575     
576     override
577     public bool visit(PGCidrExpr x) {
578         print0("cidr ");
579         x.getValue().accept(this);
580         return false;
581     }
582     
583     override
584     public void endVisit(PGCidrExpr x) {
585         
586     }
587     
588     override
589     public bool visit(PGPolygonExpr x) {
590         print0("polygon ");
591         x.getValue().accept(this);
592         return false;
593     }
594     
595     override
596     public void endVisit(PGPolygonExpr x) {
597         
598     }
599     
600     override
601     public bool visit(PGCircleExpr x) {
602         print0("circle ");
603         x.getValue().accept(this);
604         return false;
605     }
606     
607     override
608     public void endVisit(PGCircleExpr x) {
609         
610     }
611     
612     override
613     public bool visit(PGLineSegmentsExpr x) {
614         print0("lseg ");
615         x.getValue().accept(this);
616         return false;
617     }
618 
619     override
620     public void endVisit(PGLineSegmentsExpr x) {
621         
622     }
623 
624     override
625     public bool visit(SQLBinaryExpr x) {
626         print0(ucase ? "B'" : "b'");
627         print0(x.getText());
628         print('\'');
629 
630         return false;
631     }
632     
633     override
634     public void endVisit(PGShowStatement x) {
635         
636     }
637 
638     override bool visit(SQLBlobExpr x) {
639         print0("'\\x");
640         print0(x.getHex());
641         print('\'');
642 
643         return false;
644     }
645     
646     override void endVisit(SQLBlobExpr x) {
647         
648     }    
649 
650     override
651     public bool visit(PGShowStatement x) {
652         print0(ucase ? "SHOW " : "show ");
653         x.getExpr().accept(this);
654         return false;
655     }
656 
657     override public bool visit(SQLLimit x) {
658         print0(ucase ? "LIMIT " : "limit ");
659 
660         x.getRowCount().accept(this);
661 
662         if (x.getOffset() !is null) {
663             print0(ucase ? " OFFSET " : " offset ");
664             x.getOffset().accept(this);
665         }
666         return false;
667     }
668 
669     override
670     public void endVisit(PGStartTransactionStatement x) {
671         
672     }
673 
674     override
675     public bool visit(PGStartTransactionStatement x) {
676         print0(ucase ? "START TRANSACTION" : "start transaction");
677         return false;
678     }
679 
680     override
681     public void endVisit(PGConnectToStatement x) {
682 
683     }
684 
685     override
686     public bool visit(PGConnectToStatement x) {
687         print0(ucase ? "CONNECT TO " : "connect to ");
688         x.getTarget().accept(this);
689         return false;
690     }
691 
692     override
693     public bool visit(SQLSetStatement x) {
694         print0(ucase ? "SET " : "set ");
695 
696         SQLSetStatement.Option option = x.getOption();
697         if (option.name.length != 0) {
698             print(option.name());
699             print(' ');
700         }
701 
702         List!(SQLAssignItem) items = x.getItems();
703         for (int i = 0; i < items.size(); i++) {
704             if (i != 0) {
705                 print0(", ");
706             }
707 
708             SQLAssignItem item = x.getItems().get(i);
709             SQLExpr target = item.getTarget();
710             target.accept(this);
711 
712             SQLExpr value = item.getValue();
713 
714             if (cast(SQLIdentifierExpr)(target) !is null
715                     && (cast(SQLIdentifierExpr) target).getName().equalsIgnoreCase("TIME ZONE")) {
716                 print(' ');
717             } else {
718                 if (cast(SQLPropertyExpr)(value) !is null
719                         &&  cast(SQLVariantRefExpr)((cast(SQLPropertyExpr) value).getOwner()) !is null) {
720                     print0(" := ");
721                 } else {
722                     print0(" TO ");
723                 }
724             }
725 
726             if (cast(SQLListExpr)(value) !is null) {
727                 SQLListExpr listExpr = cast(SQLListExpr) value;
728                 printAndAccept!SQLExpr((listExpr.getItems()), ", ");
729             } else {
730                 value.accept(this);
731             }
732         }
733 
734         return false;
735     }
736 
737     override
738     public bool visit(SQLCreateUserStatement x) {
739         print0(ucase ? "CREATE USER " : "create user ");
740         x.getUser().accept(this);
741         print0(ucase ? " PASSWORD " : " password ");
742 
743         SQLExpr passoword = x.getPassword();
744 
745         if (cast(SQLIdentifierExpr)(passoword) !is null) {
746             print('\'');
747             passoword.accept(this);
748             print('\'');
749         } else {
750             passoword.accept(this);
751         }
752 
753         return false;
754     }
755 
756     override protected void printGrantPrivileges(SQLGrantStatement x) {
757         List!(SQLExpr) privileges = x.getPrivileges();
758         int i = 0;
759         foreach(SQLExpr privilege ; privileges) {
760             if (i != 0) {
761                 print(", ");
762             }
763 
764             if (cast(SQLIdentifierExpr)(privilege) !is null) {
765                 string name = (cast(SQLIdentifierExpr) privilege).getName();
766                 if ("RESOURCE".equalsIgnoreCase(name)) {
767                     continue;
768                 }
769             }
770 
771             privilege.accept(this);
772             i++;
773         }
774     }
775 
776     override public bool visit(SQLGrantStatement x) {
777         if (x.getOn() is null) {
778             print("ALTER ROLE ");
779             x.getTo().accept(this);
780             print(' ');
781             Set!(SQLIdentifierExpr) pgPrivilegs = new LinkedHashSet!(SQLIdentifierExpr)();
782             foreach(SQLExpr privilege ; x.getPrivileges()) {
783                 if (cast(SQLIdentifierExpr)(privilege) !is null) {
784                     string name = (cast(SQLIdentifierExpr) privilege).getName();
785                     if (equalsIgnoreCase(name, "CONNECT")) {
786                         pgPrivilegs.add(new SQLIdentifierExpr("LOGIN"));
787                     }
788                     if (toLower(name).startsWith("create ")) {
789                         pgPrivilegs.add(new SQLIdentifierExpr("CREATEDB"));
790                     }
791                 }
792             }
793             int i = 0;
794             foreach(SQLIdentifierExpr privilege ; pgPrivilegs) {
795                 if (i != 0) {
796                     print(' ');
797                 }
798                 privilege.accept(this);
799                 i++;
800             }
801             return false;
802         }
803 
804         return super.visit(x);
805     }
806     /** **************************************************************************/
807     // for oracle to postsql
808     /** **************************************************************************/
809 
810     // public bool visit(OracleSysdateExpr x) {
811     //     print0(ucase ? "CURRENT_TIMESTAMP" : "CURRENT_TIMESTAMP");
812     //     return false;
813     // }
814 
815     // override
816     // public void endVisit(OracleSysdateExpr x) {
817 
818     // }
819 
820     // override
821     // public bool visit(OracleExceptionStatement x) {
822     //     return false;
823     // }
824 
825     // override
826     // public void endVisit(OracleExceptionStatement x) {
827 
828     // }
829 
830     // override
831     // public bool visit(OracleExceptionStatement.Item x) {
832     //     return false;
833     // }
834 
835     // override
836     // public void endVisit(OracleExceptionStatement.Item x) {
837 
838     // }
839 
840     // override
841     // public bool visit(OracleArgumentExpr x) {
842     //     return false;
843     // }
844 
845     // override
846     // public void endVisit(OracleArgumentExpr x) {
847 
848     // }
849 
850     // override
851     // public bool visit(OracleSetTransactionStatement x) {
852     //     return false;
853     // }
854 
855     // override
856     // public void endVisit(OracleSetTransactionStatement x) {
857 
858     // }
859 
860     // override
861     // public bool visit(OracleExplainStatement x) {
862     //     return false;
863     // }
864 
865     // override
866     // public void endVisit(OracleExplainStatement x) {
867 
868     // }
869 
870     // override
871     // public bool visit(OracleAlterTableDropPartition x) {
872     //     return false;
873     // }
874 
875     // override
876     // public void endVisit(OracleAlterTableDropPartition x) {
877 
878     // }
879 
880     // override
881     // public bool visit(OracleAlterTableTruncatePartition x) {
882     //     return false;
883     // }
884 
885     // override
886     // public void endVisit(OracleAlterTableTruncatePartition x) {
887 
888     // }
889 
890     // override
891     // public bool visit(OracleAlterTableSplitPartition.TableSpaceItem x) {
892     //     return false;
893     // }
894 
895     // override
896     // public void endVisit(OracleAlterTableSplitPartition.TableSpaceItem x) {
897 
898     // }
899 
900     // override
901     // public bool visit(OracleAlterTableSplitPartition.UpdateIndexesClause x) {
902     //     return false;
903     // }
904 
905     // override
906     // public void endVisit(OracleAlterTableSplitPartition.UpdateIndexesClause x) {
907 
908     // }
909 
910     // override
911     // public bool visit(OracleAlterTableSplitPartition.NestedTablePartitionSpec x) {
912     //     return false;
913     // }
914 
915     // override
916     // public void endVisit(OracleAlterTableSplitPartition.NestedTablePartitionSpec x) {
917 
918     // }
919 
920     // override
921     // public bool visit(OracleAlterTableSplitPartition x) {
922     //     return false;
923     // }
924 
925     // override
926     // public void endVisit(OracleAlterTableSplitPartition x) {
927 
928     // }
929 
930     // override
931     // public bool visit(OracleAlterTableModify x) {
932     //     return false;
933     // }
934 
935     // override
936     // public void endVisit(OracleAlterTableModify x) {
937 
938     // }
939 
940     // override
941     // public bool visit(OracleCreateIndexStatement x) {
942     //     return false;
943     // }
944 
945     // override
946     // public void endVisit(OracleCreateIndexStatement x) {
947 
948     // }
949 
950     // override
951     // public bool visit(OracleForStatement x) {
952     //     return false;
953     // }
954 
955     // override
956     // public void endVisit(OracleForStatement x) {
957 
958     // }
959 
960     // public bool visit(OracleSizeExpr x) {
961     //     x.getValue().accept(this);
962     //     print0(x.getUnit().name());
963     //     return false;
964     // }
965 
966     // override
967     // public void endVisit(OracleSizeExpr x) {
968 
969     // }
970 
971     // override
972     // public bool visit(OracleFileSpecification x) {
973     //     return false;
974     // }
975 
976     // override
977     // public void endVisit(OracleFileSpecification x) {
978 
979     // }
980 
981     // override
982     // public bool visit(OracleAlterTablespaceAddDataFile x) {
983     //     return false;
984     // }
985 
986     // override
987     // public void endVisit(OracleAlterTablespaceAddDataFile x) {
988 
989     // }
990 
991     // override
992     // public bool visit(OracleAlterTablespaceStatement x) {
993     //     return false;
994     // }
995 
996     // override
997     // public void endVisit(OracleAlterTablespaceStatement x) {
998 
999     // }
1000 
1001     // override
1002     // public bool visit(OracleExitStatement x) {
1003     //     return false;
1004     // }
1005 
1006     // override
1007     // public void endVisit(OracleExitStatement x) {
1008 
1009     // }
1010 
1011     // override
1012     // public bool visit(OracleContinueStatement x) {
1013     //     return false;
1014     // }
1015 
1016     // override
1017     // public void endVisit(OracleContinueStatement x) {
1018 
1019     // }
1020 
1021     // override
1022     // public bool visit(OracleRaiseStatement x) {
1023     //     return false;
1024     // }
1025 
1026     // override
1027     // public void endVisit(OracleRaiseStatement x) {
1028 
1029     // }
1030 
1031     // override
1032     // public bool visit(OracleCreateDatabaseDbLinkStatement x) {
1033     //     return false;
1034     // }
1035 
1036     // override
1037     // public void endVisit(OracleCreateDatabaseDbLinkStatement x) {
1038 
1039     // }
1040 
1041     // override
1042     // public bool visit(OracleDropDbLinkStatement x) {
1043     //     return false;
1044     // }
1045 
1046     // override
1047     // public void endVisit(OracleDropDbLinkStatement x) {
1048 
1049     // }
1050 
1051     // override
1052     // public bool visit(OracleDataTypeIntervalYear x) {
1053     //     return false;
1054     // }
1055 
1056     // override
1057     // public void endVisit(OracleDataTypeIntervalYear x) {
1058 
1059     // }
1060 
1061     // override
1062     // public bool visit(OracleDataTypeIntervalDay x) {
1063     //     return false;
1064     // }
1065 
1066     // override
1067     // public void endVisit(OracleDataTypeIntervalDay x) {
1068 
1069     // }
1070 
1071     // override
1072     // public bool visit(OracleUsingIndexClause x) {
1073     //     return false;
1074     // }
1075 
1076     // override
1077     // public void endVisit(OracleUsingIndexClause x) {
1078 
1079     // }
1080 
1081     // override
1082     // public bool visit(OracleLobStorageClause x) {
1083     //     return false;
1084     // }
1085 
1086     // override
1087     // public void endVisit(OracleLobStorageClause x) {
1088 
1089     // }
1090 
1091     // public bool visit(OracleSelectTableReference x) {
1092     //     if (x.isOnly()) {
1093     //         print0(ucase ? "ONLY (" : "only (");
1094     //         printTableSourceExpr(x.getExpr());
1095 
1096     //         if (x.getPartition() !is null) {
1097     //             print(' ');
1098     //             x.getPartition().accept(this);
1099     //         }
1100 
1101     //         print(')');
1102     //     } else {
1103     //         printTableSourceExpr(x.getExpr());
1104 
1105     //         if (x.getPartition() !is null) {
1106     //             print(' ');
1107     //             x.getPartition().accept(this);
1108     //         }
1109     //     }
1110 
1111     //     if (x.getHints().size() > 0) {
1112     //         this.printHints(x.getHints());
1113     //     }
1114 
1115     //     if (x.getSampleClause() !is null) {
1116     //         print(' ');
1117     //         x.getSampleClause().accept(this);
1118     //     }
1119 
1120     //     if (x.getPivot() !is null) {
1121     //         println();
1122     //         x.getPivot().accept(this);
1123     //     }
1124 
1125     //     printAlias(x.getAlias());
1126 
1127     //     return false;
1128     // }
1129 
1130     // override
1131     // public void endVisit(OracleSelectTableReference x) {
1132 
1133     // }
1134 
1135     // override
1136     // public bool visit(PartitionExtensionClause x) {
1137     //     return false;
1138     // }
1139 
1140     // override
1141     // public void endVisit(PartitionExtensionClause x) {
1142 
1143     // }
1144 
1145     private void printHints(List!(SQLHint) hints) {
1146         if (hints.size() > 0) {
1147             print0("/*~ ");
1148             printAndAccept!SQLHint((hints), ", ");
1149             print0(" */");
1150         }
1151     }
1152 
1153     // public bool visit(OracleIntervalExpr x) {
1154     //     if (cast(SQLLiteralExpr)x.getValue() !is null) {
1155     //         print0(ucase ? "INTERVAL " : "interval ");
1156     //         x.getValue().accept(this);
1157     //         print(' ');
1158     //     } else {
1159     //         print('(');
1160     //         x.getValue().accept(this);
1161     //         print0(") ");
1162     //     }
1163 
1164     //     print0(x.getType().name());
1165 
1166     //     if (x.getPrecision() !is null) {
1167     //         print('(');
1168     //         printExpr(x.getPrecision());
1169     //         if (x.getFactionalSecondsPrecision() !is null) {
1170     //             print0(", ");
1171     //             print(x.getFactionalSecondsPrecision().intValue());
1172     //         }
1173     //         print(')');
1174     //     }
1175 
1176     //     if (x.getToType() !is null) {
1177     //         print0(ucase ? " TO " : " to ");
1178     //         print0(x.getToType().name());
1179     //         if (x.getToFactionalSecondsPrecision() !is null) {
1180     //             print('(');
1181     //             printExpr(x.getToFactionalSecondsPrecision());
1182     //             print(')');
1183     //         }
1184     //     }
1185 
1186     //     return false;
1187     // }
1188 
1189     // override
1190     // public bool visit(OracleOuterExpr x) {
1191     //     x.getExpr().accept(this);
1192     //     print0("(+)");
1193     //     return false;
1194     // }
1195 
1196     // override
1197     // public void endVisit(OracleDatetimeExpr x) {
1198 
1199     // }
1200 
1201     // public bool visit(OracleBinaryFloatExpr x) {
1202     //     print0(x.getValue().toString());
1203     //     print('F');
1204     //     return false;
1205     // }
1206 
1207     // override
1208     // public void endVisit(OracleBinaryFloatExpr x) {
1209 
1210     // }
1211 
1212     // public bool visit(OracleBinaryDoubleExpr x) {
1213     //     print0(x.getValue().toString());
1214     //     print('D');
1215     //     return false;
1216     // }
1217 
1218     // override
1219     // public void endVisit(OracleBinaryDoubleExpr x) {
1220 
1221     // }
1222 
1223     // override
1224     // public void endVisit(OracleCursorExpr x) {
1225 
1226     // }
1227 
1228     // override
1229     // public bool visit(OracleIsSetExpr x) {
1230     //     x.getNestedTable().accept(this);
1231     //     print0(ucase ? " IS A SET" : " is a set");
1232     //     return false;
1233     // }
1234 
1235     // override
1236     // public void endVisit(OracleIsSetExpr x) {
1237 
1238     // }
1239 
1240     // override
1241     // public bool visit(ModelClause.ReturnRowsClause x) {
1242     //     if (x.isAll()) {
1243     //         print0(ucase ? "RETURN ALL ROWS" : "return all rows");
1244     //     } else {
1245     //         print0(ucase ? "RETURN UPDATED ROWS" : "return updated rows");
1246     //     }
1247     //     return false;
1248     // }
1249 
1250     // override
1251     // public void endVisit(ModelClause.ReturnRowsClause x) {
1252 
1253     // }
1254 
1255     // override
1256     // public bool visit(ModelClause.MainModelClause x) {
1257     //     if (x.getMainModelName() !is null) {
1258     //         print0(ucase ? " MAIN " : " main ");
1259     //         x.getMainModelName().accept(this);
1260     //     }
1261 
1262     //     println();
1263     //     x.getModelColumnClause().accept(this);
1264 
1265     //     foreach(ModelClause.CellReferenceOption opt ; x.getCellReferenceOptions()) {
1266     //         println();
1267     //         print0(opt.name);
1268     //     }
1269 
1270     //     println();
1271     //     x.getModelRulesClause().accept(this);
1272 
1273     //     return false;
1274     // }
1275 
1276     // override
1277     // public void endVisit(ModelClause.MainModelClause x) {
1278 
1279     // }
1280 
1281     // override
1282     // public bool visit(ModelClause.ModelColumnClause x) {
1283     //     if (x.getQueryPartitionClause() !is null) {
1284     //         x.getQueryPartitionClause().accept(this);
1285     //         println();
1286     //     }
1287 
1288     //     print0(ucase ? "DIMENSION BY (" : "dimension by (");
1289     //     printAndAccept(x.getDimensionByColumns(), ", ");
1290     //     print(')');
1291 
1292     //     println();
1293     //     print0(ucase ? "MEASURES (" : "measures (");
1294     //     printAndAccept(x.getMeasuresColumns(), ", ");
1295     //     print(')');
1296     //     return false;
1297     // }
1298 
1299     // override
1300     // public void endVisit(ModelClause.ModelColumnClause x) {
1301 
1302     // }
1303 
1304     // override
1305     // public bool visit(ModelClause.QueryPartitionClause x) {
1306     //     print0(ucase ? "PARTITION BY (" : "partition by (");
1307     //     printAndAccept(x.getExprList(), ", ");
1308     //     print(')');
1309     //     return false;
1310     // }
1311 
1312     // override
1313     // public void endVisit(ModelClause.QueryPartitionClause x) {
1314 
1315     // }
1316 
1317     // override
1318     // public bool visit(ModelClause.ModelColumn x) {
1319     //     x.getExpr().accept(this);
1320     //     if (x.getAlias() !is null) {
1321     //         print(' ');
1322     //         print0(x.getAlias());
1323     //     }
1324     //     return false;
1325     // }
1326 
1327     // override
1328     // public void endVisit(ModelClause.ModelColumn x) {
1329 
1330     // }
1331 
1332     // override
1333     // public bool visit(ModelClause.ModelRulesClause x) {
1334     //     if (x.getOptions().size() > 0) {
1335     //         print0(ucase ? "RULES" : "rules");
1336     //         foreach(ModelClause.ModelRuleOption opt ; x.getOptions()) {
1337     //             print(' ');
1338     //             print0(opt.name);
1339     //         }
1340     //     }
1341 
1342     //     if (x.getIterate() !is null) {
1343     //         print0(ucase ? " ITERATE (" : " iterate (");
1344     //         x.getIterate().accept(this);
1345     //         print(')');
1346 
1347     //         if (x.getUntil() !is null) {
1348     //             print0(ucase ? " UNTIL (" : " until (");
1349     //             x.getUntil().accept(this);
1350     //             print(')');
1351     //         }
1352     //     }
1353 
1354     //     print0(" (");
1355     //     printAndAccept(x.getCellAssignmentItems(), ", ");
1356     //     print(')');
1357     //     return false;
1358 
1359     // }
1360 
1361     // override
1362     // public void endVisit(ModelClause.ModelRulesClause x) {
1363 
1364     // }
1365 
1366     // override
1367     // public bool visit(ModelClause.CellAssignmentItem x) {
1368     //     if (x.getOption() !is null) {
1369     //         print0(x.getOption().name);
1370     //         print(' ');
1371     //     }
1372 
1373     //     x.getCellAssignment().accept(this);
1374 
1375     //     if (x.getOrderBy() !is null) {
1376     //         print(' ');
1377     //         x.getOrderBy().accept(this);
1378     //     }
1379 
1380     //     print0(" = ");
1381     //     x.getExpr().accept(this);
1382 
1383     //     return false;
1384     // }
1385 
1386     // override
1387     // public void endVisit(ModelClause.CellAssignmentItem x) {
1388 
1389     // }
1390 
1391     // override
1392     // public bool visit(ModelClause.CellAssignment x) {
1393     //     x.getMeasureColumn().accept(this);
1394     //     print0("[");
1395     //     printAndAccept(x.getConditions(), ", ");
1396     //     print0("]");
1397     //     return false;
1398     // }
1399 
1400     // override
1401     // public void endVisit(ModelClause.CellAssignment x) {
1402 
1403     // }
1404 
1405     // override
1406     // public bool visit(ModelClause x) {
1407     //     print0(ucase ? "MODEL" : "model");
1408 
1409     //     this.indentCount++;
1410     //     foreach(ModelClause.CellReferenceOption opt ; x.getCellReferenceOptions()) {
1411     //         print(' ');
1412     //         print0(opt.name);
1413     //     }
1414 
1415     //     if (x.getReturnRowsClause() !is null) {
1416     //         print(' ');
1417     //         x.getReturnRowsClause().accept(this);
1418     //     }
1419 
1420     //     foreach(ModelClause.ReferenceModelClause item ; x.getReferenceModelClauses()) {
1421     //         print(' ');
1422     //         item.accept(this);
1423     //     }
1424 
1425     //     x.getMainModel().accept(this);
1426     //     this.indentCount--;
1427 
1428     //     return false;
1429     // }
1430 
1431     // override
1432     // public void endVisit(ModelClause x) {
1433 
1434     // }
1435 
1436     // override
1437     // public bool visit(OracleReturningClause x) {
1438     //     print0(ucase ? "RETURNING " : "returning ");
1439     //     printAndAccept(x.getItems(), ", ");
1440     //     print0(ucase ? " INTO " : " into ");
1441     //     printAndAccept(x.getValues(), ", ");
1442 
1443     //     return false;
1444     // }
1445 
1446     // override
1447     // public void endVisit(OracleReturningClause x) {
1448 
1449     // }
1450 
1451     // override
1452     // public bool visit(OracleInsertStatement x) {
1453     //     //visit(cast(SQLInsertStatement) x);
1454 
1455     //     print0(ucase ? "INSERT " : "insert ");
1456 
1457     //     if (x.getHints().size() > 0) {
1458     //         printAndAccept(x.getHints(), ", ");
1459     //         print(' ');
1460     //     }
1461 
1462     //     print0(ucase ? "INTO " : "into ");
1463 
1464     //     x.getTableSource().accept(this);
1465 
1466     //     printInsertColumns(x.getColumns());
1467 
1468     //     if (x.getValues() !is null) {
1469     //         println();
1470     //         print0(ucase ? "VALUES " : "values ");
1471     //         x.getValues().accept(this);
1472     //     } else {
1473     //         if (x.getQuery() !is null) {
1474     //             println();
1475     //             x.getQuery().accept(this);
1476     //         }
1477     //     }
1478 
1479     //     if (x.getReturning() !is null) {
1480     //         println();
1481     //         x.getReturning().accept(this);
1482     //     }
1483 
1484     //     if (x.getErrorLogging() !is null) {
1485     //         println();
1486     //         x.getErrorLogging().accept(this);
1487     //     }
1488 
1489     //     return false;
1490     // }
1491 
1492     // override
1493     // public void endVisit(OracleInsertStatement x) {
1494 
1495     // }
1496 
1497     // override
1498     // public bool visit(OracleMultiInsertStatement.InsertIntoClause x) {
1499     //     print0(ucase ? "INTO " : "into ");
1500 
1501     //     x.getTableSource().accept(this);
1502 
1503     //     if (x.getColumns().size() > 0) {
1504     //         this.indentCount++;
1505     //         println();
1506     //         print('(');
1507     //         for (int i = 0, size = x.getColumns().size(); i < size; ++i) {
1508     //             if (i != 0) {
1509     //                 if (i % 5 == 0) {
1510     //                     println();
1511     //                 }
1512     //                 print0(", ");
1513     //             }
1514     //             x.getColumns().get(i).accept(this);
1515     //         }
1516     //         print(')');
1517     //         this.indentCount--;
1518     //     }
1519 
1520     //     if (x.getValues() !is null) {
1521     //         println();
1522     //         print0(ucase ? "VALUES " : "values ");
1523     //         x.getValues().accept(this);
1524     //     } else {
1525     //         if (x.getQuery() !is null) {
1526     //             println();
1527     //             x.getQuery().accept(this);
1528     //         }
1529     //     }
1530 
1531     //     return false;
1532     // }
1533 
1534     // override
1535     // public void endVisit(OracleMultiInsertStatement.InsertIntoClause x) {
1536 
1537     // }
1538 
1539     // override
1540     // public bool visit(OracleMultiInsertStatement x) {
1541     //     print0(ucase ? "INSERT " : "insert ");
1542 
1543     //     if (x.getHints().size() > 0) {
1544     //         this.printHints(x.getHints());
1545     //     }
1546 
1547     //     if (x.getOption() !is null) {
1548     //         print0(x.getOption().name());
1549     //         print(' ');
1550     //     }
1551 
1552     //     for (int i = 0, size = x.getEntries().size(); i < size; ++i) {
1553     //         this.indentCount++;
1554     //         println();
1555     //         x.getEntries().get(i).accept(this);
1556     //         this.indentCount--;
1557     //     }
1558 
1559     //     println();
1560     //     x.getSubQuery().accept(this);
1561 
1562     //     return false;
1563     // }
1564 
1565     // override
1566     // public void endVisit(OracleMultiInsertStatement x) {
1567 
1568     // }
1569 
1570     // override
1571     // public bool visit(OracleMultiInsertStatement.ConditionalInsertClause x) {
1572     //     for (int i = 0, size = x.getItems().size(); i < size; ++i) {
1573     //         if (i != 0) {
1574     //             println();
1575     //         }
1576 
1577     //         OracleMultiInsertStatement.ConditionalInsertClauseItem item = x.getItems().get(i);
1578 
1579     //         item.accept(this);
1580     //     }
1581 
1582     //     if (x.getElseItem() !is null) {
1583     //         println();
1584     //         print0(ucase ? "ELSE" : "else");
1585     //         this.indentCount++;
1586     //         println();
1587     //         x.getElseItem().accept(this);
1588     //         this.indentCount--;
1589     //     }
1590 
1591     //     return false;
1592     // }
1593 
1594     // override
1595     // public void endVisit(OracleMultiInsertStatement.ConditionalInsertClause x) {
1596 
1597     // }
1598 
1599     // override
1600     // public bool visit(OracleMultiInsertStatement.ConditionalInsertClauseItem x) {
1601     //     print0(ucase ? "WHEN " : "when ");
1602     //     x.getWhen().accept(this);
1603     //     print0(ucase ? " THEN" : " then");
1604     //     this.indentCount++;
1605     //     println();
1606     //     x.getThen().accept(this);
1607     //     this.indentCount--;
1608     //     return false;
1609     // }
1610 
1611     // override
1612     // public void endVisit(OracleMultiInsertStatement.ConditionalInsertClauseItem x) {
1613 
1614     // }
1615 
1616     // override
1617     // public bool visit(OracleSelectQueryBlock x) {
1618     //     if (isPrettyFormat() && x.hasBeforeComment()) {
1619     //         printlnComments(x.getBeforeCommentsDirect());
1620     //     }
1621 
1622     //     print0(ucase ? "SELECT " : "select ");
1623 
1624     //     if (x.getHintsSize() > 0) {
1625     //         printAndAccept(x.getHints(), ", ");
1626     //         print(' ');
1627     //     }
1628 
1629     //     if (SQLSetQuantifier.ALL == x.getDistionOption()) {
1630     //         print0(ucase ? "ALL " : "all ");
1631     //     } else if (SQLSetQuantifier.DISTINCT == x.getDistionOption()) {
1632     //         print0(ucase ? "DISTINCT " : "distinct ");
1633     //     } else if (SQLSetQuantifier.UNIQUE == x.getDistionOption()) {
1634     //         print0(ucase ? "UNIQUE " : "unique ");
1635     //     }
1636 
1637     //     printSelectList(x.getSelectList());
1638 
1639     //     if (x.getInto() !is null) {
1640     //         println();
1641     //         print0(ucase ? "INTO " : "into ");
1642     //         x.getInto().accept(this);
1643     //     }
1644 
1645     //     println();
1646     //     print0(ucase ? "FROM " : "from ");
1647     //     if (x.getFrom() is null) {
1648     //         print0(ucase ? "DUAL" : "dual");
1649     //     } else {
1650     //         x.getFrom().accept(this);
1651     //     }
1652 
1653     //     if (x.getWhere() !is null) {
1654     //         println();
1655     //         print0(ucase ? "WHERE " : "where ");
1656     //         x.getWhere().accept(this);
1657     //     }
1658 
1659     //     printHierarchical(x);
1660 
1661     //     if (x.getGroupBy() !is null) {
1662     //         println();
1663     //         x.getGroupBy().accept(this);
1664     //     }
1665 
1666     //     if (x.getModelClause() !is null) {
1667     //         println();
1668     //         x.getModelClause().accept(this);
1669     //     }
1670 
1671     //     SQLOrderBy orderBy = x.getOrderBy();
1672     //     if (orderBy !is null) {
1673     //         println();
1674     //         orderBy.accept(this);
1675     //     }
1676 
1677     //     printFetchFirst(x);
1678 
1679     //     if (x.isForUpdate()) {
1680     //         println();
1681     //         print0(ucase ? "FOR UPDATE" : "for update");
1682     //         if (x.getForUpdateOfSize() > 0) {
1683     //             print('(');
1684     //             printAndAccept(x.getForUpdateOf(), ", ");
1685     //             print(')');
1686     //         }
1687 
1688     //         if (x.isNoWait()) {
1689     //             print0(ucase ? " NOWAIT" : " nowait");
1690     //         } else if (x.isSkipLocked()) {
1691     //             print0(ucase ? " SKIP LOCKED" : " skip locked");
1692     //         } else if (x.getWaitTime() !is null) {
1693     //             print0(ucase ? " WAIT " : " wait ");
1694     //             x.getWaitTime().accept(this);
1695     //         }
1696     //     }
1697 
1698     //     return false;
1699     // }
1700 
1701     // override
1702     // public void endVisit(OracleSelectQueryBlock x) {
1703 
1704     // }
1705 
1706     // override
1707     // public bool visit(OracleLockTableStatement x) {
1708     //     print0(ucase ? "LOCK TABLE " : "lock table ");
1709     //     x.getTable().accept(this);
1710     //     print0(ucase ? " IN " : " in ");
1711     //     print0(x.getLockMode().toString());
1712     //     print0(ucase ? " MODE " : " mode ");
1713     //     if (x.isNoWait()) {
1714     //         print0(ucase ? "NOWAIT" : "nowait");
1715     //     } else if (x.getWait() !is null) {
1716     //         print0(ucase ? "WAIT " : "wait ");
1717     //         x.getWait().accept(this);
1718     //     }
1719     //     return false;
1720     // }
1721 
1722     // override
1723     // public void endVisit(OracleLockTableStatement x) {
1724 
1725     // }
1726 
1727     // override
1728     // public bool visit(OracleAlterSessionStatement x) {
1729     //     print0(ucase ? "ALTER SESSION SET " : "alter session set ");
1730     //     printAndAccept(x.getItems(), ", ");
1731     //     return false;
1732     // }
1733 
1734     // override
1735     // public void endVisit(OracleAlterSessionStatement x) {
1736 
1737     // }
1738 
1739     // public bool visit(OracleRangeExpr x) {
1740     //     x.getLowBound().accept(this);
1741     //     print0("..");
1742     //     x.getUpBound().accept(this);
1743     //     return false;
1744     // }
1745 
1746     // override
1747     // public void endVisit(OracleRangeExpr x) {
1748 
1749     // }
1750 
1751     // override
1752     // public bool visit(OracleAlterIndexStatement x) {
1753     //     print0(ucase ? "ALTER INDEX " : "alter index ");
1754     //     x.getName().accept(this);
1755 
1756     //     if (x.getRenameTo() !is null) {
1757     //         print0(ucase ? " RENAME TO " : " rename to ");
1758     //         x.getRenameTo().accept(this);
1759     //     }
1760 
1761     //     if (x.getMonitoringUsage() !is null) {
1762     //         print0(ucase ? " MONITORING USAGE" : " monitoring usage");
1763     //     }
1764 
1765     //     if (x.getRebuild() !is null) {
1766     //         print(' ');
1767     //         x.getRebuild().accept(this);
1768     //     }
1769 
1770     //     if (x.getParallel() !is null) {
1771     //         print0(ucase ? " PARALLEL" : " parallel");
1772     //         x.getParallel().accept(this);
1773     //     }
1774 
1775     //     return false;
1776     // }
1777 
1778     // override
1779     // public void endVisit(OracleAlterIndexStatement x) {
1780 
1781     // }
1782 
1783     // public bool visit(OracleCheck x) {
1784     //     visit(cast(SQLCheck) x);
1785     //     return false;
1786     // }
1787 
1788     // override
1789     // public void endVisit(OracleCheck x) {
1790 
1791     // }
1792 
1793     // override
1794     // public bool visit(OracleSupplementalIdKey x) {
1795     //     print0(ucase ? "SUPPLEMENTAL LOG DATA (" : "supplemental log data (");
1796 
1797     //     int count = 0;
1798 
1799     //     if (x.isAll()) {
1800     //         print0(ucase ? "ALL" : "all");
1801     //         count++;
1802     //     }
1803 
1804     //     if (x.isPrimaryKey()) {
1805     //         if (count != 0) {
1806     //             print0(", ");
1807     //         }
1808     //         print0(ucase ? "PRIMARY KEY" : "primary key");
1809     //         count++;
1810     //     }
1811 
1812     //     if (x.isUnique()) {
1813     //         if (count != 0) {
1814     //             print0(", ");
1815     //         }
1816     //         print0(ucase ? "UNIQUE" : "unique");
1817     //         count++;
1818     //     }
1819 
1820     //     if (x.isUniqueIndex()) {
1821     //         if (count != 0) {
1822     //             print0(", ");
1823     //         }
1824     //         print0(ucase ? "UNIQUE INDEX" : "unique index");
1825     //         count++;
1826     //     }
1827 
1828     //     if (x.isForeignKey()) {
1829     //         if (count != 0) {
1830     //             print0(", ");
1831     //         }
1832     //         print0(ucase ? "FOREIGN KEY" : "foreign key");
1833     //         count++;
1834     //     }
1835 
1836     //     print0(ucase ? ") COLUMNS" : ") columns");
1837     //     return false;
1838     // }
1839 
1840     // override
1841     // public void endVisit(OracleSupplementalIdKey x) {
1842 
1843     // }
1844 
1845     // override
1846     // public bool visit(OracleSupplementalLogGrp x) {
1847     //     print0(ucase ? "SUPPLEMENTAL LOG GROUP " : "supplemental log group ");
1848     //     x.getGroup().accept(this);
1849     //     print0(" (");
1850     //     printAndAccept(x.getColumns(), ", ");
1851     //     print(')');
1852     //     if (x.isAlways()) {
1853     //         print0(ucase ? " ALWAYS" : " always");
1854     //     }
1855     //     return false;
1856     // }
1857 
1858     // override
1859     // public void endVisit(OracleSupplementalLogGrp x) {
1860 
1861     // }
1862 
1863     // override
1864     // public bool visit(OracleCreateTableStatement.Organization x) {
1865     //     string type = x.getType();
1866 
1867     //     print0(ucase ? "ORGANIZATION " : "organization ");
1868     //     print0(ucase ? type : toLower(type));
1869 
1870     //     printOracleSegmentAttributes(x);
1871 
1872     //     if (x.getPctthreshold() !is null) {
1873     //         println();
1874     //         print0(ucase ? "PCTTHRESHOLD " : "pctthreshold ");
1875     //         print(x.getPctfree());
1876     //     }
1877 
1878     //     if ("EXTERNAL".equalsIgnoreCase(type)) {
1879     //         print0(" (");
1880 
1881     //         this.indentCount++;
1882     //         if (x.getExternalType() !is null) {
1883     //             println();
1884     //             print0(ucase ? "TYPE " : "type ");
1885     //             x.getExternalType().accept(this);
1886     //         }
1887 
1888     //         if (x.getExternalDirectory() !is null) {
1889     //             println();
1890     //             print0(ucase ? "DEFAULT DIRECTORY " : "default directory ");
1891     //             x.getExternalDirectory().accept(this);
1892     //         }
1893 
1894     //         if (x.getExternalDirectoryRecordFormat() !is null) {
1895     //             println();
1896     //             this.indentCount++;
1897     //             print0(ucase ? "ACCESS PARAMETERS (" : "access parameters (");
1898     //             x.getExternalDirectoryRecordFormat().accept(this);
1899     //             this.indentCount--;
1900     //             println();
1901     //             print(')');
1902     //         }
1903 
1904     //         if (x.getExternalDirectoryLocation().size() > 0) {
1905     //             println();
1906     //             print0(ucase ? "LOCATION (" : " location(");
1907     //             printAndAccept(x.getExternalDirectoryLocation(), ", ");
1908     //             print(')');
1909     //         }
1910 
1911     //         this.indentCount--;
1912     //         println();
1913     //         print(')');
1914 
1915     //         if (x.getExternalRejectLimit() !is null) {
1916     //             println();
1917     //             print0(ucase ? "REJECT LIMIT " : "reject limit ");
1918     //             x.getExternalRejectLimit().accept(this);
1919     //         }
1920     //     }
1921 
1922     //     return false;
1923     // }
1924 
1925     // override
1926     // public void endVisit(OracleCreateTableStatement.Organization x) {
1927 
1928     // }
1929 
1930     // override
1931     // public bool visit(OracleCreateTableStatement.OIDIndex x) {
1932     //     print0(ucase ? "OIDINDEX" : "oidindex");
1933 
1934     //     if (x.getName() !is null) {
1935     //         print(' ');
1936     //         x.getName().accept(this);
1937     //     }
1938     //     print(" (");
1939     //     this.indentCount++;
1940     //     printOracleSegmentAttributes(x);
1941     //     this.indentCount--;
1942     //     println();
1943     //     print(")");
1944     //     return false;
1945     // }
1946 
1947     // override
1948     // public void endVisit(OracleCreateTableStatement.OIDIndex x) {
1949 
1950     // }
1951 
1952     // override
1953     // public bool visit(OracleCreatePackageStatement x) {
1954     //     if (x.isOrReplace()) {
1955     //         print0(ucase ? "CREATE OR REPLACE PACKAGE " : "create or replace procedure ");
1956     //     } else {
1957     //         print0(ucase ? "CREATE PACKAGE " : "create procedure ");
1958     //     }
1959 
1960     //     if (x.isBody()) {
1961     //         print0(ucase ? "BODY " : "body ");
1962     //     }
1963 
1964     //     x.getName().accept(this);
1965 
1966     //     if (x.isBody()) {
1967     //         println();
1968     //         print0(ucase ? "BEGIN" : "begin");
1969     //     }
1970 
1971     //     this.indentCount++;
1972 
1973     //     List!(SQLStatement) statements = x.getStatements();
1974     //     for (int i = 0, size = statements.size(); i < size; ++i) {
1975     //         println();
1976     //         SQLStatement stmt = statements.get(i);
1977     //         stmt.accept(this);
1978     //     }
1979 
1980     //     this.indentCount--;
1981 
1982     //     if (x.isBody() || statements.size() > 0) {
1983     //         println();
1984     //         print0(ucase ? "END " : "end ");
1985     //         x.getName().accept(this);
1986     //         print(';');
1987     //     }
1988 
1989     //     return false;
1990     // }
1991 
1992     // override
1993     // public void endVisit(OracleCreatePackageStatement x) {
1994 
1995     // }
1996 
1997     // override
1998     // public bool visit(OracleExecuteImmediateStatement x) {
1999     //     print0(ucase ? "EXECUTE IMMEDIATE " : "execute immediate ");
2000     //     x.getDynamicSql().accept(this);
2001 
2002     //     List!(SQLExpr) into = x.getInto();
2003     //     if (into.size() > 0) {
2004     //         print0(ucase ? " INTO " : " into ");
2005     //         printAndAccept(into, ", ");
2006     //     }
2007 
2008     //     List!(SQLArgument) using = x.getArguments();
2009     //     if (using.size() > 0) {
2010     //         print0(ucase ? " USING " : " using ");
2011     //         printAndAccept(using, ", ");
2012     //     }
2013 
2014     //     List!(SQLExpr) returnInto = x.getReturnInto();
2015     //     if (returnInto.size() > 0) {
2016     //         print0(ucase ? " RETURNNING INTO " : " returnning into ");
2017     //         printAndAccept(returnInto, ", ");
2018     //     }
2019     //     return false;
2020     // }
2021 
2022     // override
2023     // public void endVisit(OracleExecuteImmediateStatement x) {
2024 
2025     // }
2026 
2027     // override
2028     // public bool visit(OracleTreatExpr x) {
2029     //     print0(ucase ? "TREAT (" : "treat (");
2030     //     x.getExpr().accept(this);
2031     //     print0(ucase ? " AS " : " as ");
2032     //     if (x.isRef()) {
2033     //         print0(ucase ? "REF " : "ref ");
2034     //     }
2035     //     x.getType().accept(this);
2036     //     print(')');
2037     //     return false;
2038     // }
2039 
2040     // override
2041     // public void endVisit(OracleTreatExpr x) {
2042 
2043     // }
2044 
2045     // override
2046     // public bool visit(OracleCreateSynonymStatement x) {
2047     //     if (x.isOrReplace()) {
2048     //         print0(ucase ? "CREATE OR REPLACE " : "create or replace ");
2049     //     } else {
2050     //         print0(ucase ? "CREATE " : "create ");
2051     //     }
2052 
2053     //     if (x.isPublic()) {
2054     //         print0(ucase ? "PUBLIC " : "public ");
2055     //     }
2056 
2057     //     print0(ucase ? "SYNONYM " : "synonym ");
2058 
2059     //     x.getName().accept(this);
2060 
2061     //     print0(ucase ? " FOR " : " for ");
2062     //     x.getObject().accept(this);
2063 
2064     //     return false;
2065     // }
2066 
2067     // override
2068     // public void endVisit(OracleCreateSynonymStatement x) {
2069 
2070     // }
2071 
2072     // override
2073     // public bool visit(OracleCreateTypeStatement x) {
2074     //     if (x.isOrReplace()) {
2075     //         print0(ucase ? "CREATE OR REPLACE TYPE " : "create or replace type ");
2076     //     } else {
2077     //         print0(ucase ? "CREATE TYPE " : "create type ");
2078     //     }
2079 
2080     //     if (x.isBody()) {
2081     //         print0(ucase ? "BODY " : "body ");
2082     //     }
2083 
2084     //     x.getName().accept(this);
2085 
2086     //     SQLName under = x.getUnder();
2087     //     if (under !is null) {
2088     //         print0(ucase ? " UNDER " : " under ");
2089     //         under.accept(this);
2090     //     }
2091 
2092     //     SQLName authId = x.getAuthId();
2093     //     if (authId !is null) {
2094     //         print0(ucase ? " AUTHID " : " authid ");
2095     //         authId.accept(this);
2096     //     }
2097 
2098     //     if (x.isForce()) {
2099     //         print0(ucase ? "FORCE " : "force ");
2100     //     }
2101 
2102     //     List!(SQLParameter) parameters = x.getParameters();
2103     //     SQLDataType tableOf = x.getTableOf();
2104 
2105     //     if (x.isObject()) {
2106     //         print0(" AS OBJECT");
2107     //     }
2108 
2109     //     if (parameters.size() > 0) {
2110     //         if (x.isParen()) {
2111     //             print(" (");
2112     //         } else {
2113     //             print0(ucase ? " IS" : " is");
2114     //         }
2115     //         indentCount++;
2116     //         println();
2117 
2118     //         for (int i = 0; i < parameters.size(); ++i) {
2119     //             SQLParameter param = parameters.get(i);
2120     //             param.accept(this);
2121 
2122     //             SQLDataType dataType = param.getDataType();
2123 
2124     //             if (i < parameters.size() - 1) {
2125     //                 if (cast(OracleFunctionDataType)(dataType) !is null
2126     //                         && (cast(OracleFunctionDataType) dataType).getBlock() !is null) {
2127     //                     // skip
2128     //                     println();
2129     //                 } else  if (cast(OracleProcedureDataType)(dataType) !is null
2130     //                         && (cast(OracleProcedureDataType) dataType).getBlock() !is null) {
2131     //                     // skip
2132     //                     println();
2133     //                 } else {
2134     //                     println(", ");
2135     //                 }
2136     //             }
2137     //         }
2138 
2139     //         indentCount--;
2140     //         println();
2141 
2142     //         if (x.isParen()) {
2143     //             print0(")");
2144     //         } else {
2145     //             print0("END");
2146     //         }
2147     //     } else if (tableOf !is null) {
2148     //         print0(ucase ? " AS TABLE OF " : " as table of ");
2149     //         tableOf.accept(this);
2150     //     } else if (x.getVarraySizeLimit() !is null) {
2151     //         print0(ucase ? " VARRAY (" : " varray (");
2152     //         x.getVarraySizeLimit().accept(this);
2153     //         print0(ucase ? ") OF " : ") of ");
2154     //         x.getVarrayDataType().accept(this);
2155     //     }
2156 
2157     //     bool isFinal = x.getFinal();
2158     //     if (isFinal !is null) {
2159     //         if (isFinal.booleanValue()) {
2160     //             print0(ucase ? " FINAL" : " ");
2161     //         } else {
2162     //             print0(ucase ? " NOT FINAL" : " not ");
2163     //         }
2164     //     }
2165 
2166     //     bool instantiable = x.getInstantiable();
2167     //     if (instantiable !is null) {
2168     //         if (instantiable.booleanValue()) {
2169     //             print0(ucase ? " INSTANTIABLE" : " instantiable");
2170     //         } else {
2171     //             print0(ucase ? " NOT INSTANTIABLE" : " not instantiable");
2172     //         }
2173     //     }
2174 
2175     //     return false;
2176     // }
2177 
2178     // override
2179     // public void endVisit(OracleCreateTypeStatement x) {
2180 
2181     // }
2182 
2183     // override
2184     // public bool visit(OraclePipeRowStatement x) {
2185     //     print0(ucase ? "PIPE ROW(" : "pipe row(");
2186     //     printAndAccept(x.getParameters(), ", ");
2187     //     print(')');
2188     //     return false;
2189     // }
2190 
2191     // override
2192     // public void endVisit(OraclePipeRowStatement x) {
2193 
2194     // }
2195 
2196     // public bool visit(OraclePrimaryKey x) {
2197     //     visit(cast(SQLPrimaryKey) x);
2198     //     return false;
2199     // }
2200 
2201     // override
2202     // public void endVisit(OraclePrimaryKey x) {
2203 
2204     // }
2205 
2206     // override
2207     // public bool visit(OracleCreateTableStatement x) {
2208     //     printCreateTable(x, false);
2209 
2210     //     if (x.getOf() !is null) {
2211     //         println();
2212     //         print0(ucase ? "OF " : "of ");
2213     //         x.getOf().accept(this);
2214     //     }
2215 
2216     //     if (x.getOidIndex() !is null) {
2217     //         println();
2218     //         x.getOidIndex().accept(this);
2219     //     }
2220 
2221     //     if (x.getOrganization() !is null) {
2222     //         println();
2223     //         this.indentCount++;
2224     //         x.getOrganization().accept(this);
2225     //         this.indentCount--;
2226     //     }
2227 
2228     //     printOracleSegmentAttributes(x);
2229 
2230     //     if (x.isInMemoryMetadata()) {
2231     //         println();
2232     //         print0(ucase ? "IN_MEMORY_METADATA" : "in_memory_metadata");
2233     //     }
2234 
2235     //     if (x.isCursorSpecificSegment()) {
2236     //         println();
2237     //         print0(ucase ? "CURSOR_SPECIFIC_SEGMENT" : "cursor_specific_segment");
2238     //     }
2239 
2240     //     if (x.getParallel() == Boolean.TRUE) {
2241     //         println();
2242     //         print0(ucase ? "PARALLEL" : "parallel");
2243     //     } else if (x.getParallel() == Boolean.FALSE) {
2244     //         println();
2245     //         print0(ucase ? "NOPARALLEL" : "noparallel");
2246     //     }
2247 
2248     //     if (x.getCache() == Boolean.TRUE) {
2249     //         println();
2250     //         print0(ucase ? "CACHE" : "cache");
2251     //     } else if (x.getCache() == Boolean.FALSE) {
2252     //         println();
2253     //         print0(ucase ? "NOCACHE" : "nocache");
2254     //     }
2255 
2256     //     if (x.getLobStorage() !is null) {
2257     //         println();
2258     //         x.getLobStorage().accept(this);
2259     //     }
2260 
2261     //     if (x.isOnCommitPreserveRows()) {
2262     //         println();
2263     //         print0(ucase ? "ON COMMIT PRESERVE ROWS" : "on commit preserve rows");
2264     //     } else if (x.isOnCommitDeleteRows()) {
2265     //         println();
2266     //         print0(ucase ? "ON COMMIT DELETE ROWS" : "on commit delete rows");
2267     //     }
2268 
2269     //     if (x.isMonitoring()) {
2270     //         println();
2271     //         print0(ucase ? "MONITORING" : "monitoring");
2272     //     }
2273 
2274     //     SQLPartitionBy partitionBy = x.getPartitioning();
2275     //     if (partitionBy !is null) {
2276     //         println();
2277     //         print0(ucase ? "PARTITION BY " : "partition by ");
2278     //         partitionBy.accept(this);
2279     //     }
2280 
2281     //     if (x.getCluster() !is null) {
2282     //         println();
2283     //         print0(ucase ? "CLUSTER " : "cluster ");
2284     //         x.getCluster().accept(this);
2285     //         print0(" (");
2286     //         printAndAccept(x.getClusterColumns(), ",");
2287     //         print0(")");
2288     //     }
2289 
2290     //     if (x.getSelect() !is null) {
2291     //         println();
2292     //         print0(ucase ? "AS" : "as");
2293     //         println();
2294     //         x.getSelect().accept(this);
2295     //     }
2296 
2297     //     return false;
2298     // }
2299 
2300     // override
2301     // public void endVisit(OracleCreateTableStatement x) {
2302 
2303     // }
2304 
2305     // override
2306     // public bool visit(OracleAlterIndexStatement.Rebuild x) {
2307     //     print0(ucase ? "REBUILD" : "rebuild");
2308 
2309     //     if (x.getOption() !is null) {
2310     //         print(' ');
2311     //         x.getOption().accept(this);
2312     //     }
2313     //     return false;
2314     // }
2315 
2316     // override
2317     // public void endVisit(OracleAlterIndexStatement.Rebuild x) {
2318 
2319     // }
2320 
2321     // override
2322     // public bool visit(OracleStorageClause x) {
2323     //     return false;
2324     // }
2325 
2326     // override
2327     // public void endVisit(OracleStorageClause x) {
2328 
2329     // }
2330 
2331     // override
2332     // public bool visit(OracleGotoStatement x) {
2333     //     print0(ucase ? "GOTO " : "GOTO ");
2334     //     x.getLabel().accept(this);
2335     //     return false;
2336     // }
2337 
2338     // override
2339     // public void endVisit(OracleGotoStatement x) {
2340 
2341     // }
2342 
2343     // override
2344     // public bool visit(OracleLabelStatement x) {
2345     //     print0("<<");
2346     //     x.getLabel().accept(this);
2347     //     print0(">>");
2348     //     return false;
2349     // }
2350 
2351     // override
2352     // public void endVisit(OracleLabelStatement x) {
2353 
2354     // }
2355 
2356     // override
2357     // public bool visit(OracleAlterTriggerStatement x) {
2358     //     print0(ucase ? "ALTER TRIGGER " : "alter trigger ");
2359     //     x.getName().accept(this);
2360 
2361     //     if (x.isCompile()) {
2362     //         print0(ucase ? " COMPILE" : " compile");
2363     //     }
2364 
2365     //     if (x.getEnable() !is null) {
2366     //         if (x.getEnable().booleanValue()) {
2367     //             print0(ucase ? "ENABLE" : "enable");
2368     //         } else {
2369     //             print0(ucase ? "DISABLE" : "disable");
2370     //         }
2371     //     }
2372     //     return false;
2373     // }
2374 
2375     // override
2376     // public void endVisit(OracleAlterTriggerStatement x) {
2377 
2378     // }
2379 
2380     // override
2381     // public bool visit(OracleAlterSynonymStatement x) {
2382     //     print0(ucase ? "ALTER SYNONYM " : "alter synonym ");
2383     //     x.getName().accept(this);
2384 
2385     //     if (x.isCompile()) {
2386     //         print0(ucase ? " COMPILE" : " compile");
2387     //     }
2388 
2389     //     if (x.getEnable() !is null) {
2390     //         if (x.getEnable().booleanValue()) {
2391     //             print0(ucase ? "ENABLE" : "enable");
2392     //         } else {
2393     //             print0(ucase ? "DISABLE" : "disable");
2394     //         }
2395     //     }
2396     //     return false;
2397     // }
2398 
2399     // override
2400     // public void endVisit(OracleAlterSynonymStatement x) {
2401 
2402     // }
2403 
2404     // override
2405     // public bool visit(OracleAlterViewStatement x) {
2406     //     print0(ucase ? "ALTER VIEW " : "alter view ");
2407     //     x.getName().accept(this);
2408 
2409     //     if (x.isCompile()) {
2410     //         print0(ucase ? " COMPILE" : " compile");
2411     //     }
2412 
2413     //     if (x.getEnable() !is null) {
2414     //         if (x.getEnable().booleanValue()) {
2415     //             print0(ucase ? "ENABLE" : "enable");
2416     //         } else {
2417     //             print0(ucase ? "DISABLE" : "disable");
2418     //         }
2419     //     }
2420     //     return false;
2421     // }
2422 
2423     // override
2424     // public void endVisit(OracleAlterViewStatement x) {
2425 
2426     // }
2427 
2428     // override
2429     // public bool visit(OracleAlterTableMoveTablespace x) {
2430     //     print0(ucase ? " MOVE TABLESPACE " : " move tablespace ");
2431     //     x.getName().accept(this);
2432     //     return false;
2433     // }
2434 
2435     // override
2436     // public void endVisit(OracleAlterTableMoveTablespace x) {
2437 
2438     // }
2439 
2440     // public bool visit(OracleForeignKey x) {
2441     //     visit(cast(SQLForeignKeyImpl) x);
2442     //     return false;
2443     // }
2444 
2445     // override
2446     // public void endVisit(OracleForeignKey x) {
2447 
2448     // }
2449 
2450     // public bool visit(OracleUnique x) {
2451     //     visit(cast(SQLUnique) x);
2452     //     return false;
2453     // }
2454 
2455     // override
2456     // public void endVisit(OracleUnique x) {
2457 
2458     // }
2459 
2460     // public bool visit(OracleSelectSubqueryTableSource x) {
2461     //     print('(');
2462     //     this.indentCount++;
2463     //     println();
2464     //     x.getSelect().accept(this);
2465     //     this.indentCount--;
2466     //     println();
2467     //     print(')');
2468 
2469     //     if (x.getPivot() !is null) {
2470     //         println();
2471     //         x.getPivot().accept(this);
2472     //     }
2473 
2474     //     printFlashback(x.getFlashback());
2475 
2476     //     if ((x.getAlias() !is null) && (x.getAlias().length != 0)) {
2477     //         print(' ');
2478     //         print0(x.getAlias());
2479     //     }
2480 
2481     //     return false;
2482     // }
2483 
2484     // override
2485     // public bool visit(OracleSelectUnPivot x) {
2486     //     print0(ucase ? "UNPIVOT" : "unpivot");
2487     //     if (x.getNullsIncludeType() !is null) {
2488     //         print(' ');
2489     //         print0(OracleSelectUnPivot.NullsIncludeType.toString(x.getNullsIncludeType(), ucase));
2490     //     }
2491 
2492     //     print0(" (");
2493     //     if (x.getItems().size() == 1) {
2494     //         (cast(SQLExpr) x.getItems().get(0)).accept(this);
2495     //     } else {
2496     //         print0(" (");
2497     //         printAndAccept(x.getItems(), ", ");
2498     //         print(')');
2499     //     }
2500 
2501     //     if (x.getPivotFor().size() > 0) {
2502     //         print0(ucase ? " FOR " : " for ");
2503     //         if (x.getPivotFor().size() == 1) {
2504     //             (cast(SQLExpr) x.getPivotFor().get(0)).accept(this);
2505     //         } else {
2506     //             print('(');
2507     //             printAndAccept(x.getPivotFor(), ", ");
2508     //             print(')');
2509     //         }
2510     //     }
2511 
2512     //     if (x.getPivotIn().size() > 0) {
2513     //         print0(ucase ? " IN (" : " in (");
2514     //         printAndAccept(x.getPivotIn(), ", ");
2515     //         print(')');
2516     //     }
2517 
2518     //     print(')');
2519     //     return false;
2520     // }
2521 
2522     // override
2523     // public bool visit(OracleUpdateStatement x) {
2524     //     print0(ucase ? "UPDATE " : "update ");
2525 
2526     //     if (x.getHints().size() > 0) {
2527     //         printAndAccept(x.getHints(), ", ");
2528     //         print(' ');
2529     //     }
2530 
2531     //     if (x.isOnly()) {
2532     //         print0(ucase ? "ONLY (" : "only (");
2533     //         x.getTableSource().accept(this);
2534     //         print(')');
2535     //     } else {
2536     //         x.getTableSource().accept(this);
2537     //     }
2538 
2539     //     printAlias(x.getAlias());
2540 
2541     //     println();
2542 
2543     //     print0(ucase ? "SET " : "set ");
2544     //     for (int i = 0, size = x.getItems().size(); i < size; ++i) {
2545     //         if (i != 0) {
2546     //             print0(", ");
2547     //         }
2548     //         x.getItems().get(i).accept(this);
2549     //     }
2550 
2551     //     if (x.getWhere() !is null) {
2552     //         println();
2553     //         print0(ucase ? "WHERE " : "where ");
2554     //         this.indentCount++;
2555     //         x.getWhere().accept(this);
2556     //         this.indentCount--;
2557     //     }
2558 
2559     //     if (x.getReturning().size() > 0) {
2560     //         println();
2561     //         print0(ucase ? "RETURNING " : "returning ");
2562     //         printAndAccept(x.getReturning(), ", ");
2563     //         print0(ucase ? " INTO " : " into ");
2564     //         printAndAccept(x.getReturningInto(), ", ");
2565     //     }
2566 
2567     //     return false;
2568     // }
2569 
2570     // override
2571     // public bool visit(SampleClause x) {
2572     //     print0(ucase ? "SAMPLE " : "sample ");
2573 
2574     //     if (x.isBlock()) {
2575     //         print0(ucase ? "BLOCK " : "block ");
2576     //     }
2577 
2578     //     print('(');
2579     //     printAndAccept(x.getPercent(), ", ");
2580     //     print(')');
2581 
2582     //     if (x.getSeedValue() !is null) {
2583     //         print0(ucase ? " SEED (" : " seed (");
2584     //         x.getSeedValue().accept(this);
2585     //         print(')');
2586     //     }
2587 
2588     //     return false;
2589     // }
2590 
2591     // override
2592     // public void endVisit(SampleClause x) {
2593 
2594     // }
2595 
2596     // public bool visit(OracleSelectJoin x) {
2597     //     x.getLeft().accept(this);
2598     //     SQLTableSource right = x.getRight();
2599 
2600     //     if (x.getJoinType() == SQLJoinTableSource.JoinType.COMMA) {
2601     //         print0(", ");
2602     //         x.getRight().accept(this);
2603     //     } else {
2604     //         bool isRoot = cast(SQLSelectQueryBlock)x.getParent() !is null;
2605     //         if (isRoot) {
2606     //             this.indentCount++;
2607     //         }
2608 
2609     //         println();
2610     //         print0(ucase ? x.getJoinType().name : x.getJoinType().name_lcase);
2611     //         print(' ');
2612 
2613     //         if (cast(SQLJoinTableSource)(right) !is null) {
2614     //             print('(');
2615     //             right.accept(this);
2616     //             print(')');
2617     //         } else {
2618     //             right.accept(this);
2619     //         }
2620 
2621     //         if (isRoot) {
2622     //             this.indentCount--;
2623     //         }
2624 
2625     //         if (x.getCondition() !is null) {
2626     //             print0(ucase ? " ON " : " on ");
2627     //             x.getCondition().accept(this);
2628     //             print(' ');
2629     //         }
2630 
2631     //         if (x.getUsing().size() > 0) {
2632     //             print0(ucase ? " USING (" : " using (");
2633     //             printAndAccept(x.getUsing(), ", ");
2634     //             print(')');
2635     //         }
2636 
2637     //         printFlashback(x.getFlashback());
2638     //     }
2639 
2640     //     return false;
2641     // }
2642 
2643     // override
2644     // public bool visit(OracleSelectPivot x) {
2645     //     print0(ucase ? "PIVOT" : "pivot");
2646     //     if (x.isXml()) {
2647     //         print0(ucase ? " XML" : " xml");
2648     //     }
2649     //     print0(" (");
2650     //     printAndAccept(x.getItems(), ", ");
2651 
2652     //     if (x.getPivotFor().size() > 0) {
2653     //         print0(ucase ? " FOR " : " for ");
2654     //         if (x.getPivotFor().size() == 1) {
2655     //             (cast(SQLExpr) x.getPivotFor().get(0)).accept(this);
2656     //         } else {
2657     //             print('(');
2658     //             printAndAccept(x.getPivotFor(), ", ");
2659     //             print(')');
2660     //         }
2661     //     }
2662 
2663     //     if (x.getPivotIn().size() > 0) {
2664     //         print0(ucase ? " IN (" : " in (");
2665     //         printAndAccept(x.getPivotIn(), ", ");
2666     //         print(')');
2667     //     }
2668 
2669     //     print(')');
2670 
2671     //     return false;
2672     // }
2673 
2674     // override
2675     // public bool visit(OracleSelectPivot.Item x) {
2676     //     x.getExpr().accept(this);
2677     //     if ((x.getAlias() !is null) && (x.getAlias().length > 0)) {
2678     //         print0(ucase ? " AS " : " as ");
2679     //         print0(x.getAlias());
2680     //     }
2681     //     return false;
2682     // }
2683 
2684     // override
2685     // public bool visit(OracleSelectRestriction.CheckOption x) {
2686     //     print0(ucase ? "CHECK OPTION" : "check option");
2687     //     if (x.getConstraint() !is null) {
2688     //         print(' ');
2689     //         x.getConstraint().accept(this);
2690     //     }
2691     //     return false;
2692     // }
2693 
2694     // override
2695     // public bool visit(OracleSelectRestriction.ReadOnly x) {
2696     //     print0(ucase ? "READ ONLY" : "read only");
2697     //     return false;
2698     // }
2699 
2700     // public bool visit(OracleDbLinkExpr x) {
2701     //     SQLExpr expr = x.getExpr();
2702     //     if (expr !is null) {
2703     //         expr.accept(this);
2704     //         print('@');
2705     //     }
2706     //     print0(x.getDbLink());
2707     //     return false;
2708     // }
2709 
2710     // override
2711     // public void endVisit(OracleAnalytic x) {
2712 
2713     // }
2714 
2715     // override
2716     // public void endVisit(OracleAnalyticWindowing x) {
2717 
2718     // }
2719 
2720     // public void endVisit(OracleDbLinkExpr x) {
2721 
2722     // }
2723 
2724     // override
2725     // public void endVisit(OracleDeleteStatement x) {
2726 
2727     // }
2728 
2729     // override
2730     // public void endVisit(OracleIntervalExpr x) {
2731 
2732     // }
2733 
2734     // override
2735     // public void endVisit(OracleOuterExpr x) {
2736 
2737     // }
2738 
2739     // override
2740     // public void endVisit(OracleSelectJoin x) {
2741 
2742     // }
2743 
2744     // override
2745     // public void endVisit(OracleSelectPivot x) {
2746 
2747     // }
2748 
2749     // override
2750     // public void endVisit(OracleSelectPivot.Item x) {
2751 
2752     // }
2753 
2754     // override
2755     // public void endVisit(OracleSelectRestriction.CheckOption x) {
2756 
2757     // }
2758 
2759     // override
2760     // public void endVisit(OracleSelectRestriction.ReadOnly x) {
2761 
2762     // }
2763 
2764     // override
2765     // public void endVisit(OracleSelectSubqueryTableSource x) {
2766 
2767     // }
2768 
2769     // override
2770     // public void endVisit(OracleSelectUnPivot x) {
2771 
2772     // }
2773 
2774     // override
2775     // public void endVisit(OracleUpdateStatement x) {
2776 
2777     // }
2778 
2779     // public bool visit(OracleDeleteStatement x) {
2780     //     return visit(cast(SQLDeleteStatement) x);
2781     // }
2782 
2783     private void printFlashback(SQLExpr flashback) {
2784         if (flashback is null) {
2785             return;
2786         }
2787 
2788         println();
2789 
2790         if (cast(SQLBetweenExpr)(flashback) !is null) {
2791             flashback.accept(this);
2792         } else {
2793             print0(ucase ? "AS OF " : "as of ");
2794             flashback.accept(this);
2795         }
2796     }
2797 
2798     // public bool visit(OracleWithSubqueryEntry x) {
2799     //     print0(x.getAlias());
2800 
2801     //     if (x.getColumns().size() > 0) {
2802     //         print0(" (");
2803     //         printAndAccept(x.getColumns(), ", ");
2804     //         print(')');
2805     //     }
2806 
2807     //     print0(ucase ? " AS " : " as ");
2808     //     print('(');
2809     //     this.indentCount++;
2810     //     println();
2811     //     x.getSubQuery().accept(this);
2812     //     this.indentCount--;
2813     //     println();
2814     //     print(')');
2815 
2816     //     if (x.getSearchClause() !is null) {
2817     //         println();
2818     //         x.getSearchClause().accept(this);
2819     //     }
2820 
2821     //     if (x.getCycleClause() !is null) {
2822     //         println();
2823     //         x.getCycleClause().accept(this);
2824     //     }
2825     //     return false;
2826     // }
2827 
2828     // override
2829     // public void endVisit(OracleWithSubqueryEntry x) {
2830 
2831     // }
2832 
2833     // override
2834     // public bool visit(SearchClause x) {
2835     //     print0(ucase ? "SEARCH " : "search ");
2836     //     print0(x.getType().name());
2837     //     print0(ucase ? " FIRST BY " : " first by ");
2838     //     printAndAccept(x.getItems(), ", ");
2839     //     print0(ucase ? " SET " : " set ");
2840     //     x.getOrderingColumn().accept(this);
2841 
2842     //     return false;
2843     // }
2844 
2845     // override
2846     // public void endVisit(SearchClause x) {
2847 
2848     // }
2849 
2850     // override
2851     // public bool visit(CycleClause x) {
2852     //     print0(ucase ? "CYCLE " : "cycle ");
2853     //     printAndAccept(x.getAliases(), ", ");
2854     //     print0(ucase ? " SET " : " set ");
2855     //     x.getMark().accept(this);
2856     //     print0(ucase ? " TO " : " to ");
2857     //     x.getValue().accept(this);
2858     //     print0(ucase ? " DEFAULT " : " default ");
2859     //     x.getDefaultValue().accept(this);
2860 
2861     //     return false;
2862     // }
2863 
2864     // override
2865     // public void endVisit(CycleClause x) {
2866 
2867     // }
2868 
2869     // public bool visit(OracleAnalytic x) {
2870     //     print0(ucase ? "OVER (" : "over (");
2871 
2872     //     bool space = false;
2873     //     if (x.getPartitionBy().size() > 0) {
2874     //         print0(ucase ? "PARTITION BY " : "partition by ");
2875     //         printAndAccept(x.getPartitionBy(), ", ");
2876 
2877     //         space = true;
2878     //     }
2879 
2880     //     SQLOrderBy orderBy = x.getOrderBy();
2881     //     if (orderBy !is null) {
2882     //         if (space) {
2883     //             print(' ');
2884     //         }
2885     //         visit(orderBy);
2886     //         space = true;
2887     //     }
2888 
2889     //     OracleAnalyticWindowing windowing = x.getWindowing();
2890     //     if (windowing !is null) {
2891     //         if (space) {
2892     //             print(' ');
2893     //         }
2894     //         visit(windowing);
2895     //     }
2896 
2897     //     print(')');
2898 
2899     //     return false;
2900     // }
2901 
2902     // public bool visit(OracleAnalyticWindowing x) {
2903     //     print0(x.getType().name().toUpperCase());
2904     //     print(' ');
2905     //     x.getExpr().accept(this);
2906     //     return false;
2907     // }
2908 
2909     // override
2910     // public bool visit(OracleIsOfTypeExpr x) {
2911     //     printExpr(x.getExpr());
2912     //     print0(ucase ? " IS OF TYPE (" : " is of type (");
2913 
2914     //     List!(SQLExpr) types = x.getTypes();
2915     //     for (int i = 0, size = types.size(); i < size; ++i) {
2916     //         if (i != 0) {
2917     //             print0(", ");
2918     //         }
2919     //         SQLExpr type = types.get(i);
2920     //         if (Boolean.TRUE == type.getAttribute("ONLY")) {
2921     //             print0(ucase ? "ONLY " : "only ");
2922     //         }
2923     //         type.accept(this);
2924     //     }
2925 
2926     //     print(')');
2927     //     return false;
2928     // }
2929 
2930     // public void endVisit(OracleIsOfTypeExpr x) {
2931 
2932     // }
2933 
2934     // override
2935     // public bool visit(OracleRunStatement x) {
2936     //     print0("@@");
2937     //     printExpr(x.getExpr());
2938     //     return false;
2939     // }
2940 
2941     // override
2942     // public void endVisit(OracleRunStatement x) {
2943 
2944     // }
2945 
2946     override
2947     public bool visit(SQLIfStatement.Else x) {
2948         print0(ucase ? "ELSE" : "else");
2949         this.indentCount++;
2950         println();
2951 
2952         for (int i = 0, size = x.getStatements().size(); i < size; ++i) {
2953             if (i != 0) {
2954                 println();
2955             }
2956             SQLStatement item = x.getStatements().get(i);
2957             item.accept(this);
2958         }
2959 
2960         this.indentCount--;
2961         return false;
2962     }
2963 
2964     override
2965     public bool visit(SQLIfStatement.ElseIf x) {
2966         print0(ucase ? "ELSE IF " : "else if ");
2967         x.getCondition().accept(this);
2968         print0(ucase ? " THEN" : " then");
2969         this.indentCount++;
2970 
2971         for (int i = 0, size = x.getStatements().size(); i < size; ++i) {
2972             println();
2973             SQLStatement item = x.getStatements().get(i);
2974             item.accept(this);
2975         }
2976 
2977         this.indentCount--;
2978         return false;
2979     }
2980 
2981     override
2982     public bool visit(SQLIfStatement x) {
2983         print0(ucase ? "IF " : "if ");
2984         int lines = this.lines;
2985         this.indentCount++;
2986         x.getCondition().accept(this);
2987         this.indentCount--;
2988 
2989         if (lines != this.lines) {
2990             println();
2991         } else {
2992             print(' ');
2993         }
2994         print0(ucase ? "THEN" : "then");
2995 
2996         this.indentCount++;
2997         for (int i = 0, size = x.getStatements().size(); i < size; ++i) {
2998             println();
2999             SQLStatement item = x.getStatements().get(i);
3000             item.accept(this);
3001         }
3002         this.indentCount--;
3003 
3004         foreach(SQLIfStatement.ElseIf elseIf ; x.getElseIfList()) {
3005             println();
3006             elseIf.accept(this);
3007         }
3008 
3009         if (x.getElseItem() !is null) {
3010             println();
3011             x.getElseItem().accept(this);
3012         }
3013         println();
3014         print0(ucase ? "END IF" : "end if");
3015         return false;
3016     }
3017 
3018     override
3019     public bool visit(SQLCreateIndexStatement x) {
3020         print0(ucase ? "CREATE " : "create ");
3021         if (x.getType() !is null) {
3022             print0(x.getType());
3023             print(' ');
3024         }
3025 
3026         print0(ucase ? "INDEX " : "index ");
3027 
3028         x.getName().accept(this);
3029 
3030         if (x.getUsing() !is null) {
3031             print0(ucase ? " USING " : " using ");
3032             print0(x.getUsing());
3033         }
3034 
3035         print0(ucase ? " ON " : " on ");
3036         x.getTable().accept(this);
3037         print0(" (");
3038         printAndAccept!SQLSelectOrderByItem((x.getItems()), ", ");
3039         print(')');
3040 
3041         SQLExpr comment = x.getComment();
3042         if (comment !is null) {
3043             print0(ucase ? " COMMENT " : " comment ");
3044             comment.accept(this);
3045         }
3046 
3047         return false;
3048     }
3049 
3050     override
3051     public bool visit(SQLAlterTableAddColumn x) {
3052         bool odps = isOdps();
3053         print0(ucase ? "ADD COLUMN " : "add column ");
3054         printAndAccept!SQLColumnDefinition((x.getColumns()), ", ");
3055         return false;
3056     }
3057 
3058     override protected void visitAggreateRest(SQLAggregateExpr x) {
3059         SQLOrderBy orderBy = x.getWithinGroup();
3060         if (orderBy !is null) {
3061             print(' ');
3062             orderBy.accept(this);
3063         }
3064     }
3065 
3066     override protected void print0(Bytes data) {
3067         string s = format("E'%(\\\\%03o%)'", data.value());
3068         print0(s);
3069     }
3070 
3071     alias print0 = SQLASTOutputVisitor.print0;
3072 }