WikiStart: extractPLSQLModel.g2m

File extractPLSQLModel.g2m, 18.1 KB (added by jlcanovas, 8 years ago)
Line 
1hash typeMap
2        "VARCHAR" -> "VARCHAR",
3        "VARCHAR2" -> "VARCHAR2",
4        "Varchar2" -> "VARCHAR2",
5        "varchar2" -> "VARCHAR2",
6        "char" -> "CHAR",
7        "CHAR" -> "CHAR",
8        "NUMBER" -> "NUMBER",
9        "number" -> "NUMBER",
10        "Number" -> "NUMBER",
11        "date" -> "DATE",
12        default -> "VARCHAR2"
13end_hash
14
15rule 'createPLSQLDefinition'
16        from package_spec ps
17        to PLSQLDefinition
18        queries
19                seqt : //#seq_of_statements;
20        mappings
21                triggers = execute createTriggerBlock seqt;
22end_rule
23
24rule 'createTriggerBlock'
25        from seq_of_statements seqt
26        context createPLSQLDefinition
27        to TriggerBlock
28        queries
29                father: //#Trigger/seq_of_statements{this.check(seqt)};
30                block : /seqt/statement/#plsql_block;
31                decls : /block/#declare_spec;
32                stats1: /block/seq_of_statements/#statement;
33                stats2: /seqt/#statement;
34        mappings
35                if(father.hasResults) then
36                        name = father.father_name + "::" + father.trigger_name;
37                end_if
38                statements = stats2;
39end_rule
40
41rule 'createPackageFromSpec'
42        from package_spec ps
43        to Package
44        queries
45                n     : /ps/package_name[0]/#identifier;
46                specs : /ps/#package_obj_spec;
47        mappings
48                name = n.ID;
49                declarations = specs;
50end_rule
51
52rule 'createPackageFromBody'
53        from package_body pb
54        to Package
55        queries
56                n     : /pb/package_name[0]/#identifier;
57                decls : /pb/#package_obj_body;
58        mappings
59                name = n.ID;
60                declarations = decls;
61end_rule
62
63------------------------------------------------------------------------
64-- Normal Declarations
65------------------------------------------------------------------------
66
67rule 'createVariableDeclaration'
68        from declare_spec[unique]/variable_declaration ds
69        to VariableDeclaration
70        queries
71                varDec : /ds/#variable_declaration;
72                n      : /varDec/variable_name/#identifier;
73                t1     : /varDec/type_spec/#datatype;
74                t2     : /varDec/type_spec/type_name/#identifier;
75                r2     : /varDec/#type_spec/type_name;
76                exp    : /varDec/plsql_expression/#expr_bool;
77        mappings
78                if(t1.hasResults) then
79                        type = new Datatype;
80                        type.name = map typeMap(t1.TOKEN);
81                        type.range = t1.NUMBER;
82                else
83                        if(t2.hasResults) then
84                                type = new IndirectType;
85                                type.identifier = t2.ID;
86                                if(r2.hasResults) then
87                                        type.range = r2.NUMBER;
88                                end_if
89                        end_if
90                end_if
91                name = n.ID;
92                assign = exp;
93end_rule
94
95rule 'createCursorDeclaration'
96        from declare_spec[unique]/cursor_declaration ds
97        to CursorDeclaration
98        queries
99                curDec : /ds/#cursor_declaration;
100                n      : /curDec/cursor_name/#identifier;
101                args   : /curDec//#parameter_spec;
102                s      : /curDec//#select_statement;
103        mappings
104                name = n.ID;
105                select = s;
106                arguments = args;
107end_rule
108------------------------------------------------------------------------
109-- Statements
110------------------------------------------------------------------------
111
112rule 'createBlockStatement'
113        from statement/plsql_block st
114        to BlockStatement
115        queries
116                block : /st/#plsql_block;
117                decls : /block/#declare_spec;
118                stats : /block/seq_of_statements/#statement;
119        mappings
120                declarations = decls;
121                statements = stats;
122end_rule
123
124rule 'createIfStatement'
125        from statement/if_statement st
126        to IfStatement
127        queries
128                is     : /st/#if_statement;
129                ifexp  : /is/plsql_condition/#expr_bool;
130                ifstat : /is/seq_of_statements[0]/#statement;
131                elstat : /is/seq_of_statements[1]/#statement;
132        mappings
133                condition = ifexp;
134                ifStatements = ifstat;
135                elseStatements = elstat;
136end_rule
137
138rule 'createReturnStatement'
139        from statement/return_statement st
140        to ReturnStatement
141        queries
142        mappings
143end_rule
144
145rule 'createAssignment'
146        from statement/assignment_statement st
147        to AssignmentStatement
148        queries
149                as       : /st/#assignment_statement;
150                value    : /as/#lvalue;
151                exp      : /as/plsql_expression/#expr_bool;
152        mappings
153                receptor = value;
154                expression = exp;
155end_rule
156       
157skip_rule 'skiptoSelectStatement'
158        from statement/sql_statement//select_statement sqlc
159        to SelectStatement
160        queries
161                s : /sqlc//#select_statement;
162        do
163                skip s;
164end_rule
165
166rule 'createOpenStatement'
167        from statement/sql_statement//open_statement sqlc
168        to OpenStatement
169        queries
170                openSt : /sqlc//#open_statement;
171                cname  : /openSt//cursor_name/#identifier;
172                cloc   : //#declare_spec/cursor_declaration/cursor_name/identifier{ID.eq(cname.ID)};
173                ebools : /openSt/plsql_expressions//#expr_bool;
174        mappings
175                cursor = cloc;
176                exprs = ebools;
177end_rule
178
179rule 'createCloseStatement'
180        from statement/sql_statement//close_statement sqlc
181        to CloseStatement
182        queries
183                closeSt : /sqlc//#close_statement;
184                cname  : /closeSt//cursor_name/#identifier;
185                cloc   : //#declare_spec/cursor_declaration/cursor_name/identifier{ID.eq(cname.ID)};
186        mappings
187                cursor = cloc;
188end_rule
189
190rule 'createFetchStatement'
191        from statement/sql_statement//fetch_statement sqlc
192        to FetchStatement
193        queries
194                fetchSt : /sqlc//#fetch_statement;
195                cname   : /fetchSt//cursor_name/#identifier;
196                cloc    : //#declare_spec/cursor_declaration/cursor_name/identifier{ID.eq(cname.ID)};
197                vs      : /fetchSt/variable_names/#variable_name;
198        mappings
199                cursor = cloc;
200                into = vs;
201end_rule
202
203rule 'createRaiseStatement'
204        from statement/raise_statement sqlc
205        to RaiseStatement
206        queries
207                raiseSt : /sqlc//#raise_statement;
208                ename   : /raiseSt/#exception_name;
209        mappings
210                exception = extractID ename;
211end_rule
212
213skip_rule 'createFunctionCallStatement'
214        from statement/function_call st
215        to FunctionCallStatement
216        queries
217                s : /st/#function_call;
218        do
219                skip s;
220end_rule
221
222
223------------------------------------------------------------------------
224-- Working with variable references
225------------------------------------------------------------------------
226
227rule 'createReceptorFromVariable'
228        from variable_name v
229        to SQLVariable
230        queries
231                block : //#plsql_block//variable_name{this.check(v)};
232                iden  : /v/#identifier;
233                dec   : /block//#declare_spec/variable_declaration/variable_name/identifier{ID.eq(iden.ID)};
234        mappings
235                reference = dec;
236end_rule
237
238rule 'createSQLVariableFromLValue'
239        from lvalue/variable_name l
240        context createAssignment, createSelectStatement
241        to SQLVariable
242        queries
243                v     : /l/#variable_name;
244                block : //#plsql_block//variable_name{this.check(v)};
245                iden  : /v/#identifier;
246                dec   : /block//#declare_spec/variable_declaration/variable_name/identifier{ID.eq(iden.ID)};
247        mappings
248                reference = dec;
249end_rule
250
251rule 'createFormsVariableFromLValue'
252        from lvalue{COLON[0].exists} v
253        context createAssignment, createSelectStatement
254        to FormsVarRef
255        queries
256                ref : /v{COLON[0].exists}/#host_variable;
257        mappings
258                reference = extractID ref;
259end_rule       
260       
261rule 'createFormsVariableFromLValue'
262        from lvalue/record_name v
263        context createAssignment, createSelectStatement
264        to SQLVariable
265        queries
266                v     : /l/#variable_name;
267        mappings
268end_rule       
269
270
271------------------------------------------------------------------------
272-- Specifications
273------------------------------------------------------------------------
274
275rule 'createVariableSpecification'
276        from package_obj_spec/variable_declaration pos
277        to VariableDeclaration
278        queries
279                vd : /pos/#variable_declaration;
280                n  : /vd/variable_name/#identifier;
281        mappings
282                type = new Datatype;
283                type.name = "VARCHAR2";
284                name = n.ID;
285end_rule
286
287rule 'createFunctionSpecification'
288        from package_obj_spec/function_spec pos
289        to FunctionDeclaration
290        queries
291                fs : /pos/#function_spec;
292                n  : /fs/function_name/#identifier;
293        mappings
294                type = new Datatype;
295                type.name = "VARCHAR2";
296                name = n.ID;
297end_rule
298
299
300------------------------------------------------------------------------
301-- Expressions (FROM expr_bool)
302------------------------------------------------------------------------
303
304skip_rule 'skipAllBooleanRules'
305        from expr_bool{!TOKEN.exists}/expr_or{!TOKEN.exists}/expr_and{!TOKEN.exists} exp
306        to Expression
307        queries
308                s : /exp/expr_or/expr_and/#expr_not;
309        do
310                skip s;
311end_rule
312
313skip_rule 'bridgeBooleanFromExprBool'
314        from expr_bool{!TOKEN.exists} exp
315        to Expression
316        queries
317                s : /exp/#expr_or;
318        do
319                skip s;
320end_rule
321
322rule 'createBooleanFromExprBool'
323        from expr_bool{TOKEN.exists} exp
324        to BooleanExpression
325        queries
326                expo1     : /exp/#expr_or[0];
327                expo2     : /exp/#expr_or[1];
328        mappings
329                expr1 = expo1;
330                type = "OR";
331                expr2 = expo2;
332end_rule
333
334skip_rule 'bridgeBooleanFromExprOr'
335        from expr_or{!TOKEN.exists} exp
336        to Expression
337        queries
338                s : /exp/#expr_and;
339        do
340                skip s;
341end_rule
342
343rule 'createBooleanFromExprOr'
344        from expr_or{TOKEN.exists} exp
345        to BooleanExpression
346        queries
347                expa1     : /exp/#expr_and[0];
348                expa2     : /exp/#expr_and[1];
349        mappings
350                expr1 = expa1;
351                type = "AND";
352                expr2 = expa2;
353end_rule
354
355skip_rule 'createArithmeticFromExpAnd'
356        from expr_and{!TOKEN.exists} exp
357        to Expression
358        queries
359                s : /exp/#expr_not;
360        do
361                skip s;
362end_rule
363
364rule 'createBooleanFromExpAnd'
365        from expr_and{TOKEN.exists} exp
366        to NotExpression
367        queries
368                expa1     : /exp/#expr_not;
369        mappings
370                expr = expa1;   
371end_rule
372
373rule 'createBooleanFromRelationalOp4'
374        from expr_not/relational_op exp
375        to BooleanExpression
376        queries
377                op        : /exp/#relational_op;
378                expl1     : /exp/#expr_add[0];
379                expl2     : /exp/#expr_add[1];                 
380                eqOp      : /#op{EQ.exists};   
381                orOp      : /#op{OR.exists};
382                lthOp     : /#op{LTH.exists};
383                gthOp     : /#op{GTH.exists};
384                notEqOp   : /#op{NOT_EQ.exists};
385                leqOp     : /#op{LEQ.exists};
386                geqOp     : /#op{GEQ.exists};
387        mappings
388                expr1 = expl1;
389                expr2 = expl2;
390                if(eqOp.hasResults) then
391                        type = "EQUALS";
392                else
393                        if(orOp.hasResults) then
394                                type = "OR";
395                        else
396                                if(lthOp.hasResults) then
397                                        type = "LESSTHAN";
398                                else
399                                        if(gthOp.hasResults) then
400                                                type = "GREATERTHAN";
401                                        else
402                                                if(notEqOp.hasResults) then
403                                                        type = "NOTEQUALS";
404                                                else
405                                                        if(leqOp.hasResults) then
406                                                                type = "LESSEQUALS";
407                                                        else
408                                                                if(geqOp.hasResults) then
409                                                                        type = "GREATEREQUALS";
410                                                                end_if
411                                                        end_if
412                                                end_if
413                                        end_if
414                                end_if
415                        end_if
416                end_if
417end_rule
418
419rule 'createIsNotNull'
420        from expr_not{TOKEN[0].exists && TOKEN[0].eq("is") && TOKEN[1].exists && TOKEN[1].eq("not")} exp
421        to NotExpression
422        queries
423                expa   : /exp/#expr_add;
424        mappings
425                expr = new IsNullExpression;
426                expr.expr = expa;
427end_rule
428
429rule 'createIsNull'
430        from expr_not{TOKEN[0].exists && TOKEN[0].eq("is")} exp
431        to IsNullExpression
432        queries
433                expa   : /exp/#expr_add;
434        mappings
435                expr = expa;
436end_rule
437
438rule 'createNotRangeExpression'
439        from expr_not{TOKEN[0].exists && TOKEN[0].eq("not") && TOKEN[1].exists && TOKEN[1].eq("in")} exp
440        to NotExpression
441        queries
442                expa : /exp/#expr_add;
443                l    : /exp/nested_expressions/nested_expression[0]//#expr_bool;
444                u    : /exp/nested_expressions/nested_expression[1]//#expr_bool;
445        mappings
446                expr = new InRangeExpression;
447                expr.expr = expa;
448                expr.upper = u;
449                expr.lower = l;
450end_rule
451
452rule 'createRangeExpression'
453        from expr_not{TOKEN[0].exists && TOKEN[0].eq("in")} exp
454        to InRangeExpression
455        queries
456                expa : /exp/#expr_add;
457                l    : /exp/nested_expressions/nested_expression[0]//#expr_bool;
458                u    : /exp/nested_expressions/nested_expression[1]//#expr_bool;
459        mappings
460                expr = expa;
461                upper = u;
462                lower = l;
463end_rule
464
465rule 'createFoundExpression'
466        from expr_not{FOUND_ATTR.exists} exp
467        to FoundExpression
468        queries
469                expa : /exp/expr_add//#identifier;
470                cloc   : //#declare_spec/cursor_declaration/cursor_name/identifier{ID.eq(expa.ID)};             
471        mappings
472                cursor = cloc;
473end_rule
474
475skip_rule 'skipFromExprNotToExprAdd'
476        from expr_not exp
477        to Expression
478        queries
479                s : /exp/#expr_add;
480        do
481                skip s;
482end_rule
483
484------------------------------------------------------------------------
485-- Expressions (FROM expr_add)
486------------------------------------------------------------------------
487
488skip_rule 'skipAllArithmeticRules'
489        from expr_add{!PLUS.exists && !MINUS.exists && !DOUBLEVERTBAR.exists}/expr_mul{!ASTERISK.exists && !DIVIDE.exists}/expr_sign{!PLUS.exists && !MINUS.exists}/expr_pow{!EXPONENT.exists} exp
490        to Expression
491        queries
492                s : /exp//#expr_expr;
493        do
494                skip s;
495end_rule
496       
497rule 'createArithmeticFromAddPlus'
498        from expr_add{PLUS.exists} exp
499        to ArithmeticExpression
500        queries
501                expa1 : /exp/#expr_mul[0];
502                expa2 : /exp/#expr_mul[1];
503        mappings
504                expr1 = expa1;
505                type = "PLUS";
506                expr2 = expa2;
507end_rule
508
509rule 'createArithmeticFromAddMinus'
510        from expr_add{MINUS.exists} exp
511        to ArithmeticExpression
512        queries
513                expa1 : /exp/#expr_mul[0];
514                expa2 : /exp/#expr_mul[1];
515        mappings
516                expr1 = expa1;
517                type = "MINUS";
518                expr2 = expa2;
519end_rule
520
521rule 'createArithmeticFromAddDoubleBar'
522        from expr_add{DOUBLEVERTBAR.exists} exp
523        to ConcatString
524        queries
525                exps : /exp/#expr_mul;
526        mappings
527                exprs = exps;
528end_rule
529
530skip_rule 'skipToExprMul'
531        from expr_add{!PLUS.exists && !MINUS.exists && !DOUBLEVERTBAR.exists} exp
532        to Expression
533        queries
534                s : /exp/#expr_mul;
535        do
536                skip s;
537end_rule
538
539rule 'createArithmeticFromMulAsterisk'
540        from expr_mul{ASTERISK.exists} exp
541        to ArithmeticExpression
542        queries
543                expa1 : /exp/#expr_sign[0];
544                expa2 : /exp/#expr_sign[1];
545        mappings
546                expr1 = expa1;
547                type = "MULTIPLICATION";
548                expr2 = expa2;
549end_rule
550
551rule 'createArithmeticFromMulDivide'
552        from expr_mul{DIVIDE.exists} exp
553        to ArithmeticExpression
554        queries
555                expa1 : /exp/#expr_sign[0];
556                expa2 : /exp/#expr_sign[1];
557        mappings
558                expr1 = expa1;
559                type = "DIVISION";
560                expr2 = expa2;
561end_rule
562
563skip_rule 'skipToExprSign'
564        from expr_mul{!ASTERISK.exists && !DIVIDE.exists} exp
565        to Expression
566        queries
567                s : /exp/#expr_sign;
568        do
569                skip s;
570end_rule
571
572rule 'createArithmeticFromSignPositive'
573        from expr_sign{PLUS.exists} exp
574        to ArithmeticExpression
575        queries
576                expa1 : /exp/#expr_pow[0];
577        mappings
578                expr1 = expa1;
579                type = "POSITIVE";
580end_rule
581
582rule 'createArithmeticFromSignNegative'
583        from expr_sign{MINUS.exists} exp
584        to ArithmeticExpression
585        queries
586                expa1 : /exp/#expr_pow[0];
587        mappings
588                expr1 = expa1;
589                type = "NEGATIVE";
590end_rule
591
592skip_rule 'skipToExprPow'
593        from expr_sign{!PLUS.exists && !MINUS.exists} exp
594        to Expression
595        queries
596                s : /exp/#expr_pow;
597        do
598                skip s;
599end_rule
600
601rule 'createArithmethicFromPow'
602        from expr_pow{EXPONENT.exists} exp
603        to ArithmeticExpression
604        queries
605                expa1 : /exp/#expr_expr[0];
606                expa2 : /exp/#expr_expr[1];
607        mappings
608                expr1 = expa1;
609                type = "EXPONENT";
610                expr2 = expa2;
611end_rule
612
613skip_rule 'skipToExprExpr'
614        from expr_pow{!EXPONENT.exists} exp
615        to Expression
616        queries
617                s : /exp/#expr_expr;
618        do
619                skip s;
620end_rule
621
622rule 'createFormsVariableFromExpAdd'
623        from expr_expr/simple_expression{COLON.exists} ea
624        to FormsVarRef
625        queries
626                se : /ea//simple_expression/#host_variable;
627        mappings
628                reference = extractID se;
629end_rule
630
631skip_rule 'createFunctionCallFromExprAddFunctionExpr'
632        from expr_expr/function_expression exp
633        to Expression
634        queries
635                s     : /exp//function_expression/#function_call;               
636                block : //#plsql_block///expr_expr{this.check(exp)};
637                iden  : /s//#identifier;
638                dec   : /block//#declare_spec/variable_declaration/variable_name/identifier{ID.eq(iden.ID)};
639                cast1  : (variable_name) /s//#sql_identifier/identifier;       
640                cast2  : /s//#variable_name/identifier;
641        do
642                if(dec.hasResults) then
643                        if(cast1.hasResults) then
644                                skip cast1;
645                        else
646                                skip cast2;
647                        end_if
648                else
649                        skip s;
650                end_if
651end_rule
652
653rule 'createLiteralFromExprAddQuotedString'
654        from expr_expr/simple_expression{QUOTED_STRING.exists || TOKEN.exists || NUMBER.exists} exp
655        to LiteralExpression
656        queries
657                st           : /exp//#simple_expression;
658                stringExists : /exp//#simple_expression{QUOTED_STRING.exists};
659                nullExists   : /exp//#simple_expression{TOKEN.exists};
660                numberExists : /exp//#simple_expression{NUMBER.exists};
661        mappings
662                if(stringExists.hasResults) then
663                        type = "STRING";
664                else
665                        if(nullExists.hasResults) then
666                                type = "NULL";
667                        else
668                                if(numberExists.hasResults) then
669                                        type = "INTEGER";
670                                end_if
671                        end_if
672                end_if
673                value = extract st;
674end_rule
675
676skip_rule 'skipToExprBoolFromExprParen'
677        from expr_expr/expr_paren exp
678        to Expression
679        queries
680                s : /exp//#expr_bool;
681        do
682                skip s;
683end_rule
684
685------------------------------------------------------------------------
686-- Function Call
687------------------------------------------------------------------------
688
689rule 'createFunctionCallGeneral'
690        from function_call  fc
691        to FunctionCallStatement
692        queries
693                iden   : /fc/user_defined_function//#identifier;
694                params : /fc/call_parameters/#call_parameter;
695                exp    : /fc//#nested_expression;
696        mappings
697                name = iden.ID;
698                parameters = params;
699                --expr = exp;
700end_rule
701
702rule 'createFunctionCallParamForFunctionCall'
703        from call_parameter cp
704        to FunctionCallParameter
705        queries
706                iden  : /cp/parameter_name/#identifier;
707                exp   : /cp//plsql_expression/#expr_bool;
708        mappings
709                name = iden.ID;
710                expr = exp;
711end_rule
712
713
714------------------------------------------------------------------------
715-- Select Statement
716------------------------------------------------------------------------
717
718rule 'createSelectStatement'
719        from select_statement sel
720        to SelectStatement
721        queries
722                sexpr   : /sel/#select_expression;
723                list    : /sexpr//#displayed_column;
724                isCount : /list//#keyCOUNT;
725                lvals   : /sexpr//lvalues/#lvalue;
726                fromn   : /sexpr/#table_reference_list;
727                fromj   : /sexpr/#join_clause;
728                w       : /sexpr//where_clause/#sql_condition;
729        mappings
730                if(isCount.hasResults) then
731                        isCount = "true";
732                end_if
733                selectList = extractID list;
734                into = lvals;
735                if(fromn.hasResults) then
736                        _from = extractID fromn;
737                else
738                        _from = extractID fromj;
739                end_if
740                where = w;
741end_rule
742
743------------------------------------------------------------------------
744-- Conditions
745------------------------------------------------------------------------
746
747rule 'createConditionComparison'
748        from sql_condition//condition_comparison sc
749        to ConditionComparison
750        queries
751                compar    : /sc//#condition_comparison;
752                exp1      : /compar/sql_expression[0]/#expr_add;
753                exp2      : /compar/sql_expression[1]/#expr_add;               
754                eqOp      : /#compar{EQ.exists};                       
755                orOp      : /#compar{OR.exists};
756                lthOp     : /#compar{LTH.exists};
757                gthOp     : /#compar{GTH.exists};
758                notEqOp   : /#compar{NOT_EQ.exists};
759                leqOp     : /#compar{LEQ.exists};
760                geqOp     : /#compar{GEQ.exists};
761        mappings
762                expr1 = exp1;
763                expr2 = exp2;
764                if(eqOp.hasResults) then
765                        type = "EQUALS";
766                else
767                        if(orOp.hasResults) then
768                                type = "OR";
769                        else
770                                if(lthOp.hasResults) then
771                                        type = "LESSTHAN";
772                                else
773                                        if(gthOp.hasResults) then
774                                                type = "GREATERTHAN";
775                                        else
776                                                if(notEqOp.hasResults) then
777                                                        type = "NOTEQUALS";
778                                                else
779                                                        if(leqOp.hasResults) then
780                                                                type = "LESSEQUALS";
781                                                        else
782                                                                if(geqOp.hasResults) then
783                                                                        type = "GREATEREQUALS";
784                                                                end_if
785                                                        end_if
786                                                end_if
787                                        end_if
788                                end_if
789                        end_if
790                end_if
791end_rule