exits = EcoreUtil2.getAllContentsOfType(container, ExitStatement.class);
333 | for (ExitStatement exit : exits) {
334 | if (containsSimpleExpressionName(exit.getCondition(), varName)) {
335 | found = true;
336 | break;
337 | }
338 | }
339 | }
340 | return found;
341 | }
342 | return false;
343 | }
344 |
345 | @Check
346 | public void checkVariableName(VariableDeclaration v) {
347 | final EObject parent = v.eContainer().eContainer();
348 | final String name = v.getVariable().getValue().toLowerCase();
349 | if (isSysRefcursor(v)) {
350 | if (!name.matches(REGEX_CURSOR_NAME)) {
351 | warning(ISSUE_CURSOR_NAME, v.getVariable(), v);
352 | }
353 | } else if (isObjectType(v)) {
354 | if (!name.matches(REGEX_OBJECT_NAME)) {
355 | warning(ISSUE_OBJECT_NAME, v.getVariable(), v);
356 | }
357 | } else if (isCollectionType(v)) {
358 | if (!name.matches(REGEX_ARRAY_NAME)) {
359 | warning(ISSUE_ARRAY_NAME, v.getVariable(), v);
360 | }
361 | } else if (isRowtype(v) || isRecordType(v)) {
362 | if (!name.matches(REGEX_RECORD_NAME)) {
363 | warning(ISSUE_RECORD_NAME, v.getVariable(), v);
364 | }
365 | } else {
366 | // reduce false positives, skip checking variables base on qualified UDTs
367 | if (!isQualifiedUdt(v)) {
368 | if (parent instanceof CreatePackage || parent instanceof CreatePackageBody) {
369 | if (!name.matches(REGEX_GLOBAL_VARIABLE_NAME)) {
370 | warning(ISSUE_GLOBAL_VARIABLE_NAME, v.getVariable(), v);
371 | }
372 | } else {
373 | // reduce false positives, allow cursor/object/array names and loop indices (e.g. i and j)
374 | if (!name.matches(REGEX_LOCAL_VARIABLE_NAME) && !name.matches(REGEX_CURSOR_NAME)
375 | && !name.matches(REGEX_OBJECT_NAME) && !name.matches(REGEX_ARRAY_NAME)
376 | && !isLoopIndexVariable(v.getVariable())) {
377 | warning(ISSUE_LOCAL_VARIABLE_NAME, v.getVariable(), v);
378 | }
379 | }
380 | }
381 | }
382 | }
383 |
384 | @Check
385 | public void checkCursorName(CursorDeclarationOrDefinition c) {
386 | if (!c.getCursor().getValue().toLowerCase().matches(REGEX_CURSOR_NAME)) {
387 | warning(ISSUE_CURSOR_NAME, c.getCursor());
388 | }
389 | for (final ParameterDeclaration p : c.getParams()) {
390 | if (!p.getParameter().getValue().toLowerCase().matches(REGEX_CURSOR_PARAMETER_NAME)) {
391 | warning(ISSUE_CURSOR_PARAMETER_NAME, p.getParameter(), p);
392 | }
393 | }
394 | }
395 |
396 | @Check
397 | public void checkParameterName(ParameterDeclaration p) {
398 | final EObject parent = p.eContainer();
399 | if (!(parent instanceof CursorDeclarationOrDefinition)) {
400 | final String name = p.getParameter().getValue();
401 | if (!("self".equalsIgnoreCase(name))) {
402 | if (p.isIn() && p.isOut()) {
403 | if (!name.matches(REGEX_IN_OUT_PARAMETER_NAME)) {
404 | warning(ISSUE_IN_OUT_PARAMETER_NAME, p.getParameter(), p);
405 | }
406 | } else if (p.isOut()) {
407 | if (!name.matches(REGEX_OUT_PARAMETER_NAME)) {
408 | warning(ISSUE_OUT_PARAMETER_NAME, p.getParameter(), p);
409 | }
410 | } else {
411 | if (!name.matches(REGEX_IN_PARAMETER_NAME)) {
412 | warning(ISSUE_IN_PARAMETER_NAME, p.getParameter(), p);
413 | }
414 | }
415 | }
416 | }
417 | }
418 |
419 | @Check
420 | public void checkRecordTypeName(RecordTypeDefinition rt) {
421 | final String name = rt.getType().getValue().toLowerCase();
422 | if (!(name.matches(REGEX_RECORD_TYPE_NAME))) {
423 | warning(ISSUE_RECORD_TYPE_NAME, rt.getType(), rt);
424 | }
425 | }
426 |
427 | @Check
428 | public void checkArrayTypeName(CollectionTypeDefinition ct) {
429 | final String name = ct.getType().getValue().toLowerCase();
430 | if (!(name.matches(REGEX_ARRAY_TYPE_NAME))) {
431 | warning(ISSUE_ARRAY_TYPE_NAME, ct.getType(), ct);
432 | }
433 | }
434 |
435 | @Check
436 | public void checkExceptionName(ExceptionDeclaration e) {
437 | if (!e.getException().getValue().toLowerCase().matches(REGEX_EXCEPTION_NAME)) {
438 | warning(ISSUE_EXCEPTION_NAME, e.getException(), e);
439 | }
440 | }
441 |
442 | @Check
443 | public void checkConstantName(ConstantDeclaration co) {
444 | if (!co.getConstant().getValue().toLowerCase().matches(REGEX_CONSTANT_NAME)) {
445 | warning(ISSUE_CONSTANT_NAME, co.getConstant(), co);
446 | }
447 | }
448 |
449 | @Check
450 | public void checkSubtypeName(SubTypeDefinition st) {
451 | if (!st.getType().getValue().toLowerCase().matches(REGEX_SUBTYPE_NAME)) {
452 | warning(ISSUE_SUBTYPE_NAME, st.getType(), st);
453 | }
454 | }
455 | }
456 |
--------------------------------------------------------------------------------
/src/main/resources/GLP/genmodel/plsqlcop-model.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | CHANGEABILITY
6 | Changeability
7 |
8 | ARCHITECTURE_CHANGEABILITY
9 | Architecture changeability
10 |
11 |
12 | DATA_CHANGEABILITY
13 | Data changeability
14 |
15 |
16 | LOGIC_CHANGEABILITY
17 | Logic changeability
18 |
19 |
20 |
21 | EFFICIENCY
22 | Efficiency
23 |
24 | CPU_EFFICIENCY
25 | Cpu efficiency
26 |
27 |
28 | MEMORY_EFFICIENCY
29 | Memory efficiency
30 |
31 |
32 | NETWORK_USE
33 | Network use
34 |
35 |
36 |
37 | MAINTAINABILITY
38 | Maintainability
39 |
40 | READABILITY
41 | Readability
42 |
43 |
44 | UNDERSTANDABILITY
45 | Understandability
46 |
47 |
48 | trivadis
49 | G-0000
50 |
51 | remediationFunction
52 | CONSTANT_ISSUE
53 |
54 |
55 | remediationFactor
56 | 0.0
57 | mn
58 |
59 |
60 | offset
61 | 0.0
62 | mn
63 |
64 |
65 |
66 |
67 | trivadis
68 | G-9001
69 |
70 | remediationFunction
71 | CONSTANT_ISSUE
72 |
73 |
74 | remediationFactor
75 | 0.0
76 | mn
77 |
78 |
79 | offset
80 | 1.0
81 | mn
82 |
83 |
84 |
85 |
86 | trivadis
87 | G-9002
88 |
89 | remediationFunction
90 | CONSTANT_ISSUE
91 |
92 |
93 | remediationFactor
94 | 0.0
95 | mn
96 |
97 |
98 | offset
99 | 1.0
100 | mn
101 |
102 |
103 |
104 |
105 | trivadis
106 | G-9003
107 |
108 | remediationFunction
109 | CONSTANT_ISSUE
110 |
111 |
112 | remediationFactor
113 | 0.0
114 | mn
115 |
116 |
117 | offset
118 | 1.0
119 | mn
120 |
121 |
122 |
123 |
124 |
125 | PORTABILITY
126 | Portability
127 |
128 | COMPILER_RELATED_PORTABILITY
129 | Compiler related portability
130 |
131 |
132 | HARDWARE_RELATED_PORTABILITY
133 | Hardware related portability
134 |
135 |
136 | LANGUAGE_RELATED_PORTABILITY
137 | Language related portability
138 |
139 |
140 | OS_RELATED_PORTABILITY
141 | Os related portability
142 |
143 |
144 | SOFTWARE_RELATED_PORTABILITY
145 | Software related portability
146 |
147 |
148 | TIME_ZONE_RELATED_PORTABILITY
149 | Time zone related portability
150 |
151 |
152 |
153 | RELIABILITY
154 | Reliability
155 |
156 | ARCHITECTURE_RELIABILITY
157 | Architecture reliability
158 |
159 |
160 | ARCHITECTURE_RELIABILITY
161 | Architecture reliability
162 |
163 |
164 | trivadis
165 | E-0001
166 |
167 | remediationFunction
168 | CONSTANT_ISSUE
169 |
170 |
171 | remediationFactor
172 | 0.0
173 | mn
174 |
175 |
176 | offset
177 | 1.0
178 | mn
179 |
180 |
181 |
182 |
183 | trivadis
184 | E-0002
185 |
186 | remediationFunction
187 | CONSTANT_ISSUE
188 |
189 |
190 | remediationFactor
191 | 0.0
192 | mn
193 |
194 |
195 | offset
196 | 1.0
197 | mn
198 |
199 |
200 |
201 |
202 | trivadis
203 | E-0003
204 |
205 | remediationFunction
206 | CONSTANT_ISSUE
207 |
208 |
209 | remediationFactor
210 | 0.0
211 | mn
212 |
213 |
214 | offset
215 | 1.0
216 | mn
217 |
218 |
219 |
220 |
221 | DATA_RELIABILITY
222 | Data reliability
223 |
224 |
225 | EXCEPTION_HANDLING
226 | Exception handling
227 |
228 |
229 | FAULT_TOLERANCE
230 | Fault tolerance
231 |
232 |
233 | INSTRUCTION_RELIABILITY
234 | Instruction reliability
235 |
236 |
237 | LOGIC_RELIABILITY
238 | Logic reliability
239 |
240 |
241 | RESOURCE_RELIABILITY
242 | Resource reliability
243 |
244 |
245 | SYNCHRONIZATION_RELIABILITY
246 | Synchronization reliability
247 |
248 |
249 | UNIT_TESTS
250 | Unit tests
251 |
252 |
253 |
254 | REUSABILITY
255 | Reusability
256 |
257 | MODULARITY
258 | Modularity
259 |
260 |
261 | TRANSPORTABILITY
262 | Transportability
263 |
264 |
265 |
266 | SECURITY
267 | Security
268 |
269 | API_ABUSE
270 | Api abuse
271 |
272 |
273 | ERRORS
274 | Errors
275 |
276 |
277 | INPUT_VALIDATION_AND_REPRESENTATION
278 | Input validation and representation
279 |
280 |
281 | SECURITY_FEATURES
282 | Security features
283 |
284 |
285 |
286 | TESTABILITY
287 | Testability
288 |
289 | INTEGRATION_TESTABILITY
290 | Integration testability
291 |
292 |
293 | UNIT_TESTABILITY
294 | Unit testability
295 |
296 |
297 |
298 |
--------------------------------------------------------------------------------
/src/main/resources/GLP/genmodel/rules.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | G-0000
6 |
7 | CODE_SMELL
8 | G-0000
9 | INFO
10 | SINGLE
11 | READY
12 | ]]>
14 | avoid
15 |
16 |
17 | G-9001
18 |
19 | CODE_SMELL
20 | G-9001
21 | MINOR
22 | SINGLE
23 | READY
24 | Reason
26 | To easily distinguish between global and local variables.
27 | Furthermore, the use of a prefix avoids naming conflicts with reserved words.
28 | Bad
29 | create or replace package pkg as
30 | global_variable integer;
31 | end pkg;
32 | /
33 | Good
34 | create or replace package pkg as
35 | g_global_variable integer;
36 | end pkg;
37 | /
38 | ]]>
39 | always
40 |
41 |
42 | G-9002
43 |
44 | CODE_SMELL
45 | G-9002
46 | MINOR
47 | SINGLE
48 | READY
49 | Reason
51 | To easily distinguish between global and local variables.
52 | Furthermore, the use of a prefix avoids naming conflicts with reserved words.
53 | Bad
54 | create or replace procedure p as
55 | c integer;
56 | begin
57 | null;
58 | end p;
59 | /
60 | Good
61 | create or replace procedure p as
62 | l_something integer;
63 | begin
64 | null;
65 | end p;
66 | /
67 | ]]>
68 | always
69 |
70 |
71 | G-9003
72 |
73 | CODE_SMELL
74 | G-9003
75 | MINOR
76 | SINGLE
77 | READY
78 | Reason
80 | To easily distinguish between parameters and variables.
81 | Furthermore, the use of a prefix avoids naming conflicts with reserved words.
82 | Bad
83 | create or replace procedure p (a in integer, b in varchar2) as
84 | begin
85 | null;
86 | end p;
87 | /
88 | Good
89 | create or replace procedure p (p_1 in integer, p_2 in varchar2) as
90 | begin
91 | null;
92 | end p;
93 | /
94 | ]]>
95 | always
96 |
97 |
98 | E-0001
99 | E-0001: Timeout occurred (after n seconds) during load/parse/validation of resource.
100 | BUG
101 | E-0001
102 | BLOCKER
103 | SINGLE
104 | READY
105 | Reason
107 | Processing large SQL files takes time. Increase the db* CODECOP timeout parameter to avoid this error. The default timeout per file is 10 seconds.
108 | ]]>
109 | error
110 |
111 |
112 | E-0002
113 | E-0002: Syntax error. Please check the limitations and contact the author if the code can be compiled successfully in your environment.
114 | BUG
115 | E-0002
116 | BLOCKER
117 | SINGLE
118 | READY
119 | Reason
121 | It's either a db* CODECOP bug or a limitation, if the code compiles successfully in your environment.
122 | Please note, that syntax errors may lead to false positives. db* CODECOP will therefore not report guideline violations, if a syntax error was encountered in the processed file.
123 | ]]>
124 | error
125 |
126 |
127 | E-0003
128 | E-0003: License limit reached.
129 | BUG
130 | E-0003
131 | BLOCKER
132 | SINGLE
133 | READY
134 | Reason
136 | A db* CODECOP license key defines limitations for the validity date, the major version, the number of files, the number of lines, the number commands and the number of bytes to be processed. Please contact your sales representative to obtain a less restrictive license.
137 | ]]>
138 | error
139 |
140 |
141 |
--------------------------------------------------------------------------------
/src/main/resources/GLP/sample/guideline_9001.sql:
--------------------------------------------------------------------------------
1 | -- G-9001 Always prefix global variables with 'g_'.
2 |
3 | -- Reason
4 | /*To easily distinguish between global and local variables.
*/
5 | /*Furthermore, the use of a prefix avoids naming conflicts with reserved words.
*/
6 |
7 | -- Bad
8 | create or replace package pkg as
9 | global_variable integer;
10 | end pkg;
11 | /
12 |
13 | -- Good
14 | create or replace package pkg as
15 | g_global_variable integer;
16 | end pkg;
17 | /
18 |
--------------------------------------------------------------------------------
/src/main/resources/GLP/sample/guideline_9002.sql:
--------------------------------------------------------------------------------
1 | -- G-9002: Always prefix local variables with 'l_'.
2 |
3 | -- Reason
4 | /*To easily distinguish between global and local variables.
*/
5 | /*Furthermore, the use of a prefix avoids naming conflicts with reserved words.
*/
6 |
7 | -- Bad
8 | create or replace procedure p as
9 | c integer;
10 | begin
11 | null;
12 | end p;
13 | /
14 |
15 | -- Good
16 | create or replace procedure p as
17 | l_something integer;
18 | begin
19 | null;
20 | end p;
21 | /
22 |
--------------------------------------------------------------------------------
/src/main/resources/GLP/sample/guideline_9003.sql:
--------------------------------------------------------------------------------
1 | -- G-9003: Always prefix parameters with 'p_'.
2 |
3 | -- Reason
4 | /*To easily distinguish between parameters and variables.
*/
5 | /*Furthermore, the use of a prefix avoids naming conflicts with reserved words.
*/
6 |
7 | -- Bad
8 | create or replace procedure p (a in integer, b in varchar2) as
9 | begin
10 | null;
11 | end p;
12 | /
13 |
14 | -- Good
15 | create or replace procedure p (p_1 in integer, p_2 in varchar2) as
16 | begin
17 | null;
18 | end p;
19 | /
20 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9101.sql:
--------------------------------------------------------------------------------
1 | -- G-9101: Always name global variables to match '^g_.+$'.
2 |
3 | -- Reason
4 | /*See Naming Conventions for PL/SQL.
5 | You can override the default via system property REGEX_GLOBAL_VARIABLE_NAME.
*/
6 |
7 | -- Bad
8 | create or replace package body example as
9 | some_name integer;
10 | end example;
11 | /
12 |
13 | -- Good
14 | create or replace package body example as
15 | g_some_name integer;
16 | end example;
17 | /
18 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9102.sql:
--------------------------------------------------------------------------------
1 | -- G-9102: Always name local variables to match '^l_.+$'.
2 |
3 | -- Reason
4 | /*See Naming Conventions for PL/SQL.
5 | You can override the default via system property REGEX_LOCAL_VARIABLE_NAME.
*/
6 |
7 | -- Bad
8 | declare
9 | some_name integer;
10 | begin
11 | null;
12 | end;
13 | /
14 |
15 | -- Good
16 | declare
17 | l_some_name integer;
18 | begin
19 | null;
20 | end;
21 | /
22 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9103.sql:
--------------------------------------------------------------------------------
1 | -- G-9103: Always name cursors to match '^c_.+$'.
2 |
3 | -- Reason
4 | /*See Naming Conventions for PL/SQL.
5 | You can override the default via system property REGEX_CURSOR_NAME.
*/
6 |
7 | -- Bad
8 | declare
9 | l_dept sys_refcursor;
10 | begin
11 | null;
12 | end;
13 | /
14 |
15 | -- Good
16 | declare
17 | c_dept sys_refcursor;
18 | begin
19 | null;
20 | end;
21 | /
22 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9104.sql:
--------------------------------------------------------------------------------
1 | -- G-9104: Always name records to match '^r_.+$'.
2 |
3 | -- Reason
4 | /*See Naming Conventions for PL/SQL.
5 | You can override the default via system property REGEX_RECORD_NAME.
*/
6 |
7 | -- Bad
8 | declare
9 | emp emp%rowtype;
10 | type r_dept_type is record(
11 | deptno number,
12 | dname varchar2(14 char),
13 | loc loc(13 char)
14 | );
15 | dept r_dept_type;
16 | begin
17 | null;
18 | end;
19 | /
20 |
21 | -- Good
22 | declare
23 | r_emp emp%rowtype;
24 | type r_dept_type is record(
25 | deptno number,
26 | dname varchar2(14 char),
27 | loc loc(13 char)
28 | );
29 | r_dept r_dept_type;
30 | begin
31 | null;
32 | end;
33 | /
34 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9105.sql:
--------------------------------------------------------------------------------
1 | -- G-9105: Always name collection types (arrays/tables) to match '^t_.+$'.
2 |
3 | -- Reason
4 | /*See Naming Conventions for PL/SQL.
5 | You can override the default via system property REGEX_ARRAY_NAME.
*/
6 |
7 | -- Bad
8 | declare
9 | type t_varray_type is varray(10) of string;
10 | array1 t_varray_type;
11 | type t_nested_table_type is table of string;
12 | array2 t_nested_table_type;
13 | type t_assoc_array_type is table of string index by pls_integer;
14 | array3 t_assoc_array_type;
15 | begin
16 | null;
17 | end;
18 | /
19 |
20 | -- Good
21 | declare
22 | type t_varray_type is varray(10) of string;
23 | t_array1 t_varray_type;
24 | type t_nested_table_type is table of string;
25 | t_array2 t_nested_table_type;
26 | type t_assoc_array_type is table of string index by pls_integer;
27 | t_array3 t_assoc_array_type;
28 | begin
29 | null;
30 | end;
31 | /
32 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9106.sql:
--------------------------------------------------------------------------------
1 | -- G-9106: Always name objects to match '^o_.+$'.
2 |
3 | -- Reason
4 | /*See Naming Conventions for PL/SQL.
5 | You can override the default via system property REGEX_OBJECT_NAME.
*/
6 |
7 | -- Bad
8 | create or replace type dept_type as object (
9 | deptno integer,
10 | dname varchar2(14 char),
11 | loc varchar2(13 char)
12 | );
13 | /
14 |
15 | declare
16 | dept dept_type;
17 | begin
18 | null;
19 | end;
20 | /
21 |
22 | -- Good
23 | create or replace type dept_type as object (
24 | deptno integer,
25 | dname varchar2(14 char),
26 | loc varchar2(13 char)
27 | );
28 | /
29 |
30 | declare
31 | o_dept dept_type;
32 | begin
33 | null;
34 | end;
35 | /
36 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9107.sql:
--------------------------------------------------------------------------------
1 | -- G-9107: Always name cursor parameters to match '^p_.+$'.
2 |
3 | -- Reason
4 | /*See Naming Conventions for PL/SQL.
5 | You can override the default via system property REGEX_CURSOR_PARAMETER_NAME.
*/
6 |
7 | -- Bad
8 | declare
9 | cursor c_emp(in_ename in varchar2) is
10 | select *
11 | from emp
12 | where ename like in_ename;
13 | begin
14 | null;
15 | end;
16 | /
17 |
18 | -- Good
19 | declare
20 | cursor c_emp(p_ename in varchar2) is
21 | select *
22 | from emp
23 | where ename like p_ename;
24 | begin
25 | null;
26 | end;
27 | /
28 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9108.sql:
--------------------------------------------------------------------------------
1 | -- G-9108: Always name in parameters to match '^in_.+$'.
2 |
3 | -- Reason
4 | /*See Naming Conventions for PL/SQL.
5 | You can override the default via system property REGEX_IN_PARAMETER_NAME.
*/
6 |
7 | -- Bad
8 | create or replace package p is
9 | procedure p2(param in integer);
10 | end p;
11 | /
12 |
13 | -- Good
14 | create or replace package p is
15 | procedure p2(in_param in integer);
16 | end p;
17 | /
18 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9109.sql:
--------------------------------------------------------------------------------
1 | -- G-9109: Always name out parameters to match '^out_.+$'.
2 |
3 | -- Reason
4 | /*See Naming Conventions for PL/SQL.
5 | You can override the default via system property REGEX_OUT_PARAMETER_NAME.
*/
6 |
7 | -- Bad
8 | create or replace package p is
9 | procedure p2(param out integer);
10 | end p;
11 | /
12 |
13 | -- Good
14 | create or replace package p is
15 | procedure p2(out_param out integer);
16 | end p;
17 | /
18 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9110.sql:
--------------------------------------------------------------------------------
1 | -- G-9110: Always name in/out parameters to match '^io_.+$'.
2 |
3 | -- Reason
4 | /*See Naming Conventions for PL/SQL.
5 | You can override the default via system property REGEX_IN_OUT_PARAMETER_NAME.
*/
6 |
7 | -- Bad
8 | create or replace package p is
9 | procedure p2(param in out integer);
10 | end p;
11 | /
12 |
13 | -- Good
14 | create or replace package p is
15 | procedure p2(io_param in out integer);
16 | end p;
17 | /
18 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9111.sql:
--------------------------------------------------------------------------------
1 | -- G-9111: Always name record type definitions to match '^r_.+_type$'.
2 |
3 | -- Reason
4 | /*See Naming Conventions for PL/SQL.
5 | You can override the default via system property REGEX_RECORD_TYPE_NAME.
*/
6 |
7 | -- Bad
8 | declare
9 | type dept_typ is
10 | record(
11 | deptno number,
12 | dname varchar2(14 char),
13 | loc loc(13 char)
14 | );
15 | begin
16 | null;
17 | end;
18 | /
19 |
20 | -- Good
21 | declare
22 | type r_dept_type is
23 | record(
24 | deptno number,
25 | dname varchar2(14 char),
26 | loc loc(13 char)
27 | );
28 | begin
29 | null;
30 | end;
31 | /
32 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9112.sql:
--------------------------------------------------------------------------------
1 | -- G-9112: Always name collection type definitions (arrays/tables) to match '^t_.+_type$'.
2 |
3 | -- Reason
4 | /*See Naming Conventions for PL/SQL.
5 | You can override the default via system property REGEX_ARRAY_TYPE_NAME.
*/
6 |
7 | -- Bad
8 | declare
9 | type t_varray is varray(10) of string;
10 | type nested_table_type is table of string;
11 | type x_assoc_array_y is table of string index by pls_integer;
12 | begin
13 | null;
14 | end;
15 | /
16 |
17 | -- Good
18 | declare
19 | type t_varray_type is varray(10) of string;
20 | type t_nested_table_type is table of string;
21 | type t_assoc_array_type is table of string index by pls_integer;
22 | begin
23 | null;
24 | end;
25 | /
26 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9113.sql:
--------------------------------------------------------------------------------
1 | -- G-9113: Always name exceptions to match '^e_.+$'.
2 |
3 | -- Reason
4 | /*See Naming Conventions for PL/SQL.
5 | You can override the default via system property REGEX_EXCEPTION_NAME.
*/
6 |
7 | -- Bad
8 | declare
9 | some_name exception;
10 | begin
11 | null;
12 | end;
13 | /
14 |
15 | -- Good
16 | declare
17 | e_some_name exception;
18 | begin
19 | null;
20 | end;
21 | /
22 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9114.sql:
--------------------------------------------------------------------------------
1 | -- G-9114: Always name constants to match '^co_.+$'.
2 |
3 | -- Reason
4 | /*See Naming Conventions for PL/SQL.
5 | You can override the default via system property REGEX_CONSTANT_NAME.
*/
6 |
7 | -- Bad
8 | declare
9 | maximum constant integer := 1000;
10 | begin
11 | null;
12 | end;
13 | /
14 |
15 | -- Good
16 | declare
17 | co_maximum constant integer := 1000;
18 | begin
19 | null;
20 | end;
21 | /
22 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9115.sql:
--------------------------------------------------------------------------------
1 | -- G-9115: Always name subtypes to match '^.+_type$'.
2 |
3 | -- Reason
4 | /*See Naming Conventions for PL/SQL.
5 | You can override the default via system property REGEX_SUBTYPE_NAME.
*/
6 |
7 | -- Bad
8 | declare
9 | subtype short_text is varchar2(100 char);
10 | begin
11 | null;
12 | end;
13 | /
14 |
15 | -- Good
16 | declare
17 | subtype short_text_type is varchar2(100 char);
18 | begin
19 | null;
20 | end;
21 | /
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9501.sql:
--------------------------------------------------------------------------------
1 | -- G-9501: Never use parameter in string expression of dynamic SQL. Use asserted local variable instead.
2 |
3 | -- Reason
4 | /*The use of static SQL eliminates the risk of SQL injection. However, if you write
5 | dynamic SQL you are responsible to ensure that the SQL cannot be injected with malicious
6 | SQL statements.
7 | */
8 |
9 | /*
This check looks for unasserted parameters used in execute immediate statements
10 | and open for statements. All parameters used in these statements must be asserted with
11 | one of the subprograms provided by dbms_assert.
*/
12 |
13 | -- Bad
14 | -- The input parameter in_table_name is copied to the local variable l_table_name and then used
15 | -- without an assert to build the l_sql variable. Hence, the execute immediate statement is
16 | -- considered vulnerable to SQL injection, e.g. by passing DEPT CASCADE CONSTRAINTS.
17 | create or replace package body pkg is
18 | function f (in_table_name in varchar2) return boolean as
19 | co_templ constant varchar2(4000 byte) := 'DROP TABLE #in_table_name# PURGE';
20 | l_table_name varchar2(128 byte);
21 | l_sql varchar2(4000 byte);
22 | begin
23 | l_table_name := in_table_name;
24 | l_sql := replace(co_templ, '#in_table_name#', l_table_name);
25 | execute immediate l_sql;
26 | return true;
27 | end f;
28 | end pkg;
29 | /
30 |
31 | -- Good
32 | -- SQL injection is not possible, because the input parameter in_table_name is
33 | -- checked/modified with sys.dbms_assert.enquote_name.
34 | create or replace package body pkg is
35 | function f (in_table_name in varchar2) return boolean as
36 | co_templ constant varchar2(4000 byte) := 'DROP TABLE #in_table_name# PURGE';
37 | l_table_name varchar2(128 byte);
38 | l_sql varchar2(4000 byte);
39 | begin
40 | l_table_name := sys.dbms_assert.enquote_name(in_table_name);
41 | l_sql := replace(co_templ, '#in_table_name#', l_table_name);
42 | execute immediate l_sql;
43 | return true;
44 | end f;
45 | end pkg;
46 | /
47 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9600.sql:
--------------------------------------------------------------------------------
1 | -- G-9600: Never define more than one comment with hints.
2 |
3 | -- Reason
4 | /*Only the first comment containing hints is considered by the Oracle Database,
5 | therefore all hints violating this rule are treated as ordinary comments.
*/
6 |
7 | -- Bad
8 | select -- a comment
9 | /*+ full(e) */
10 | /* another comment */
11 | --+ full(d)
12 | e.empno,
13 | e.ename,
14 | d.dname
15 | from emp e
16 | join dept d
17 | on d.deptno = e.deptno
18 | where empno > 7900;
19 |
20 | select * from dbms_xplan.display_cursor(format => 'basic +hint_report');
21 |
22 | /*
23 | ------------------------------------------------
24 | | Id | Operation | Name |
25 | ------------------------------------------------
26 | | 0 | SELECT STATEMENT | |
27 | | 1 | NESTED LOOPS | |
28 | | 2 | NESTED LOOPS | |
29 | | 3 | TABLE ACCESS FULL | EMP |
30 | | 4 | INDEX UNIQUE SCAN | PK_DEPT |
31 | | 5 | TABLE ACCESS BY INDEX ROWID| DEPT |
32 | ------------------------------------------------
33 |
34 | Hint Report (identified by operation id / Query Block Name / Object Alias):
35 | Total hints for statement: 1
36 | ---------------------------------------------------------------------------
37 |
38 | 3 - SEL$58A6D7F6 / E@SEL$1
39 | - full(e)
40 | */
41 |
42 | -- Better
43 | select -- a comment
44 | /*+ full(e) full(d) */
45 | /* another comment */
46 | e.empno,
47 | e.ename,
48 | d.dname
49 | from emp e
50 | join dept d
51 | on d.deptno = e.deptno
52 | where empno > 7900;
53 |
54 | select * from dbms_xplan.display_cursor(format => 'basic +hint_report');
55 |
56 | /*
57 | -----------------------------------
58 | | Id | Operation | Name |
59 | -----------------------------------
60 | | 0 | SELECT STATEMENT | |
61 | | 1 | HASH JOIN | |
62 | | 2 | TABLE ACCESS FULL| EMP |
63 | | 3 | TABLE ACCESS FULL| DEPT |
64 | -----------------------------------
65 |
66 | Hint Report (identified by operation id / Query Block Name / Object Alias):
67 | Total hints for statement: 2
68 | ---------------------------------------------------------------------------
69 |
70 | 2 - SEL$58A6D7F6 / E@SEL$1
71 | - full(e)
72 |
73 | 3 - SEL$58A6D7F6 / D@SEL$1
74 | - full(d)
75 | */
76 |
77 | -- Good
78 | -- do not mix single-line and mult-line comments
79 | -- use hints first or hints last, do not hide them within other comments
80 | select --+ full(e) full(d)
81 | -- a comment
82 | -- another comment
83 | e.empno,
84 | e.ename,
85 | d.dname
86 | from emp e
87 | join dept d
88 | on d.deptno = e.deptno
89 | where empno > 7900;
90 |
91 | select * from dbms_xplan.display_cursor(format => 'basic +hint_report');
92 |
93 | /*
94 | -----------------------------------
95 | | Id | Operation | Name |
96 | -----------------------------------
97 | | 0 | SELECT STATEMENT | |
98 | | 1 | HASH JOIN | |
99 | | 2 | TABLE ACCESS FULL| EMP |
100 | | 3 | TABLE ACCESS FULL| DEPT |
101 | -----------------------------------
102 |
103 | Hint Report (identified by operation id / Query Block Name / Object Alias):
104 | Total hints for statement: 2
105 | ---------------------------------------------------------------------------
106 |
107 | 2 - SEL$58A6D7F6 / E@SEL$1
108 | - full(e)
109 |
110 | 3 - SEL$58A6D7F6 / D@SEL$1
111 | - full(d)
112 | */
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9601.sql:
--------------------------------------------------------------------------------
1 | -- G-9601: Never use unknown hints.
2 |
3 | -- Reason
4 | /*Using unknown hints might invalidate all subsequent hints.
5 | This happens when you use for example NOLOGGING. That's expected
6 | and not a bug. See MOS note 285285.1 or bug 8432870 for details.
*/
7 |
8 | -- Bad
9 | -- "nologging" is not a hint. It does not exist in v$sql_hint.
10 | -- The "append" hint is ignored as a result "LOAD TABLE CONVENTIONAL" is applied.
11 | insert --+ nologging append
12 | into sales_hist
13 | select * from sales;
14 |
15 | select * from dbms_xplan.display_cursor(format => 'basic');
16 |
17 | /*
18 | -----------------------------------------------
19 | | Id | Operation | Name |
20 | -----------------------------------------------
21 | | 0 | INSERT STATEMENT | |
22 | | 1 | LOAD TABLE CONVENTIONAL | SALES_HIST |
23 | | 2 | PARTITION RANGE ALL | |
24 | | 3 | TABLE ACCESS FULL | SALES |
25 | -----------------------------------------------
26 | */
27 |
28 |
29 | -- Good
30 | -- "nologging" is applied on the table, however this is in most
31 | -- environments overridden by the force logging option on database level.
32 | -- The "append" hint is applied, as a result "LOAD AS SELECT" is applied.
33 | alter table sales_hist nologging;
34 |
35 | insert --+ append
36 | into sales_hist
37 | select * from sales;
38 |
39 | select * from dbms_xplan.display_cursor(format => 'basic');
40 |
41 | /*
42 | -------------------------------------------------------
43 | | Id | Operation | Name |
44 | -------------------------------------------------------
45 | | 0 | INSERT STATEMENT | |
46 | | 1 | LOAD AS SELECT | SALES_HIST |
47 | | 2 | OPTIMIZER STATISTICS GATHERING | |
48 | | 3 | PARTITION RANGE ALL | |
49 | | 4 | TABLE ACCESS FULL | SALES |
50 | -------------------------------------------------------
51 | */
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9602.sql:
--------------------------------------------------------------------------------
1 | -- G-9602: Always use the alias name instead of the table name.
2 |
3 | -- Reason
4 | /* There are various hints that reference a table or view. Typically, if an alias is defined
5 | for a table/view, but the table/view name is used in the hint, then the hint is
6 | ignored by the Oracle Database.
*/
7 |
8 | -- Bad
9 | select --+ leading(emp dept)
10 | *
11 | from emp e
12 | join dept d on d.deptno = e.deptno;
13 |
14 | select * from dbms_xplan.display_cursor(format => 'basic +hint_report');
15 |
16 | /*
17 | ------------------------------------------------
18 | | Id | Operation | Name |
19 | ------------------------------------------------
20 | | 0 | SELECT STATEMENT | |
21 | | 1 | MERGE JOIN | |
22 | | 2 | TABLE ACCESS BY INDEX ROWID| DEPT |
23 | | 3 | INDEX FULL SCAN | PK_DEPT |
24 | | 4 | SORT JOIN | |
25 | | 5 | TABLE ACCESS FULL | EMP |
26 | ------------------------------------------------
27 |
28 | Hint Report (identified by operation id / Query Block Name / Object Alias):
29 | Total hints for statement: 1 (U - Unused (1))
30 | ---------------------------------------------------------------------------
31 |
32 | 1 - SEL$58A6D7F6
33 | U - leading(emp dept)
34 | */
35 |
36 |
37 | -- Good
38 | select --+ leading(e d)
39 | *
40 | from emp e
41 | join dept d on d.deptno = e.deptno;
42 |
43 | select * from dbms_xplan.display_cursor(format => 'basic +hint_report');
44 |
45 | /*
46 | -----------------------------------
47 | | Id | Operation | Name |
48 | -----------------------------------
49 | | 0 | SELECT STATEMENT | |
50 | | 1 | HASH JOIN | |
51 | | 2 | TABLE ACCESS FULL| EMP |
52 | | 3 | TABLE ACCESS FULL| DEPT |
53 | -----------------------------------
54 |
55 | Hint Report (identified by operation id / Query Block Name / Object Alias):
56 | Total hints for statement: 1
57 | ---------------------------------------------------------------------------
58 |
59 | 1 - SEL$58A6D7F6
60 | - leading(e d)
61 | */
62 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9603.sql:
--------------------------------------------------------------------------------
1 | -- G-9603: Never reference an unknown table/alias.
2 |
3 | -- Reason
4 | /* There are various hints that reference a table or view. If the table or
5 | view reference in the hint is neither a table name nor an alias, then the hint
6 | is ignored by the Oracle Database.
*/
7 |
8 | -- Bad
9 | select --+ leading(emps depts)
10 | *
11 | from emp
12 | join dept on emp.deptno = dept.deptno;
13 |
14 | select * from dbms_xplan.display_cursor(format => 'basic +hint_report');
15 |
16 | /*
17 | ------------------------------------------------
18 | | Id | Operation | Name |
19 | ------------------------------------------------
20 | | 0 | SELECT STATEMENT | |
21 | | 1 | MERGE JOIN | |
22 | | 2 | TABLE ACCESS BY INDEX ROWID| DEPT |
23 | | 3 | INDEX FULL SCAN | PK_DEPT |
24 | | 4 | SORT JOIN | |
25 | | 5 | TABLE ACCESS FULL | EMP |
26 | ------------------------------------------------
27 |
28 | Hint Report (identified by operation id / Query Block Name / Object Alias):
29 | Total hints for statement: 1 (U - Unused (1))
30 | ---------------------------------------------------------------------------
31 |
32 | 1 - SEL$58A6D7F6
33 | U - leading(emps depts)
34 | */
35 |
36 |
37 | -- Good
38 | select --+ leading(emp dept)
39 | *
40 | from emp
41 | join dept on emp.deptno = dept.deptno;
42 |
43 | select * from dbms_xplan.display_cursor(format => 'basic +hint_report');
44 |
45 | /*
46 | -----------------------------------
47 | -----------------------------------
48 | | Id | Operation | Name |
49 | -----------------------------------
50 | | 0 | SELECT STATEMENT | |
51 | | 1 | HASH JOIN | |
52 | | 2 | TABLE ACCESS FULL| EMP |
53 | | 3 | TABLE ACCESS FULL| DEPT |
54 | -----------------------------------
55 |
56 | Hint Report (identified by operation id / Query Block Name / Object Alias):
57 | Total hints for statement: 1
58 | ---------------------------------------------------------------------------
59 |
60 | 1 - SEL$58A6D7F6
61 | - leading(emp dept)
62 | */
63 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9604.sql:
--------------------------------------------------------------------------------
1 | -- G-9604: Never use an invalid stats method.
2 |
3 | -- Reason
4 | /*The syntax for the gather_stats hints is:
5 | table_stats([<schema>.]<table> <method> [,] <keyword>=<value> [[,] <keyword>=<value>]...)
6 | Valid methods are:
7 |
8 | - DEFAULT
9 | - SET
10 | - SCALE
11 | - SAMPLE
12 |
13 | The Oracle Database treats other methods as a syntax error and will ignore the hint.
*/
14 |
15 | -- Bad
16 | select /*+ table_stats(emp faster rows=14) */ empno, ename
17 | from emp e
18 | where deptno = 20;
19 | select * from dbms_xplan.display_cursor(format => 'basic +hint_report');
20 |
21 | /*
22 | ----------------------------------
23 | | Id | Operation | Name |
24 | ----------------------------------
25 | | 0 | SELECT STATEMENT | |
26 | | 1 | TABLE ACCESS FULL| EMP |
27 | ----------------------------------
28 |
29 | Hint Report (identified by operation id / Query Block Name / Object Alias):
30 | Total hints for statement: 1 (E - Syntax error (1))
31 | ---------------------------------------------------------------------------
32 |
33 | 1 - SEL$1
34 | E - table_stats
35 | */
36 |
37 | -- Good
38 | select /*+ table_stats(emp set rows=14) */ empno, ename
39 | from emp e
40 | where deptno = 20;
41 | select * from dbms_xplan.display_cursor(format => 'basic +hint_report');
42 |
43 | /*
44 | ----------------------------------
45 | | Id | Operation | Name |
46 | ----------------------------------
47 | | 0 | SELECT STATEMENT | |
48 | | 1 | TABLE ACCESS FULL| EMP |
49 | ----------------------------------
50 |
51 | Hint Report (identified by operation id / Query Block Name / Object Alias):
52 | Total hints for statement: 1
53 | ---------------------------------------------------------------------------
54 |
55 | 0 - STATEMENT
56 | - table_stats(emp set rows=14)
57 | */
58 |
--------------------------------------------------------------------------------
/src/main/resources/TrivadisGuidelines3Plus/sample/guideline_9605.sql:
--------------------------------------------------------------------------------
1 | -- G-9605: Never use an invalid stats keyword.
2 |
3 | -- Reason
4 | /*The syntax for the gather_stats hints is:
5 | table_stats([<schema>.]<table> <method> [,] <keyword>=<value> [[,] <keyword>=<value>]...)
6 | Valid keywords are:
7 |
8 | - ROWS
9 | - BLOCKS
10 | - ROW_LENGTH
11 |
12 | The Oracle Database treats other keywords as a syntax error and will ignore the hint.
*/
13 |
14 | -- Bad
15 | select /*+ table_stats(emp default rec=14 blk=1 rowlen=10) */ empno, ename
16 | from emp e
17 | where deptno = 20;
18 | select * from dbms_xplan.display_cursor(format => 'basic +hint_report');
19 |
20 | /*
21 | ----------------------------------
22 | | Id | Operation | Name |
23 | ----------------------------------
24 | | 0 | SELECT STATEMENT | |
25 | | 1 | TABLE ACCESS FULL| EMP |
26 | ----------------------------------
27 |
28 | Hint Report (identified by operation id / Query Block Name / Object Alias):
29 | Total hints for statement: 1 (E - Syntax error (1))
30 | ---------------------------------------------------------------------------
31 |
32 | 1 - SEL$1
33 | E - table_stats
34 | */
35 |
36 | -- Good
37 | select /*+ table_stats(emp default rows=14 blocks=1 row_length=10) */ empno, ename
38 | from emp e
39 | where deptno = 20;
40 | select * from dbms_xplan.display_cursor(format => 'basic +hint_report');
41 |
42 | /*
43 | ----------------------------------
44 | | Id | Operation | Name |
45 | ----------------------------------
46 | | 0 | SELECT STATEMENT | |
47 | | 1 | TABLE ACCESS FULL| EMP |
48 | ----------------------------------
49 |
50 | Hint Report (identified by operation id / Query Block Name / Object Alias):
51 | Total hints for statement: 1
52 | ---------------------------------------------------------------------------
53 |
54 | 0 - STATEMENT
55 | - table_stats(emp set rows=14)
56 | */
57 |
--------------------------------------------------------------------------------
/src/test/java/com/trivadis/tvdcc/validators/tests/AbstractValidatorTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017 Philipp Salvisberg
3 | *
4 | * Licensed under the Creative Commons Attribution-NonCommercial-NoDerivs 3.0
5 | * Unported License (the "License"); you may not use this file except
6 | * in compliance with the License. You may obtain a copy of the License at
7 | *
8 | * https://creativecommons.org/licenses/by-nc-nd/3.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 | package com.trivadis.tvdcc.validators.tests;
17 |
18 | import com.google.inject.Injector;
19 | import com.trivadis.oracle.plsql.PLSQLStandaloneSetup;
20 | import com.trivadis.oracle.plsql.validation.PLSQLCopGuideline;
21 | import com.trivadis.oracle.plsql.validation.PLSQLValidator;
22 | import com.trivadis.tvdcc.validators.TrivadisPlsqlNaming;
23 | import java.io.ByteArrayInputStream;
24 | import java.io.File;
25 | import java.io.IOException;
26 | import java.nio.charset.Charset;
27 | import java.nio.file.Files;
28 | import java.nio.file.Path;
29 | import java.nio.file.Paths;
30 | import java.nio.file.StandardCopyOption;
31 | import java.util.List;
32 |
33 | import org.eclipse.emf.common.util.EList;
34 | import org.eclipse.emf.common.util.URI;
35 | import org.eclipse.emf.ecore.resource.Resource;
36 | import org.eclipse.xtext.resource.XtextResource;
37 | import org.eclipse.xtext.resource.XtextResourceSet;
38 | import org.eclipse.xtext.validation.CheckMode;
39 | import org.eclipse.xtext.validation.Issue;
40 | import org.junit.AfterClass;
41 | import org.junit.BeforeClass;
42 | import org.junit.Test;
43 |
44 | import static org.hamcrest.MatcherAssert.assertThat;
45 | import static org.hamcrest.core.AnyOf.anyOf;
46 | import static org.hamcrest.core.StringStartsWith.startsWith;
47 |
48 | public abstract class AbstractValidatorTest {
49 | private static final String PROPERTIES_FILE_NAME = TrivadisPlsqlNaming.PROPERTIES_FILE_NAME;
50 | public static final String FULL_PROPERTIES_FILE_NAME = ((System.getProperty("user.home") + File.separator)
51 | + PROPERTIES_FILE_NAME);
52 | private static final String FULL_PROPERTIES_FILE_NAME_BACKUP = (FULL_PROPERTIES_FILE_NAME + ".backup");
53 |
54 | private final Injector injector = new PLSQLStandaloneSetup().createInjectorAndDoEMFRegistration();
55 |
56 | @BeforeClass
57 | public static void commonSetup() {
58 | stashPropertiesFile();
59 | }
60 |
61 | public static void stashPropertiesFile() {
62 | try {
63 | final Path file = Path.of(FULL_PROPERTIES_FILE_NAME);
64 | if (Files.exists(file)) {
65 | Files.copy(file, Paths.get(FULL_PROPERTIES_FILE_NAME_BACKUP));
66 | Files.delete(file);
67 | }
68 | } catch (IOException e) {
69 | throw new RuntimeException(e);
70 | }
71 | }
72 |
73 | @AfterClass
74 | public static void restorePropertiesFile() {
75 | try {
76 | final Path original = Path.of(FULL_PROPERTIES_FILE_NAME_BACKUP);
77 | final Path file = Path.of(FULL_PROPERTIES_FILE_NAME);
78 | if (Files.exists(original)) {
79 | Files.copy(original, file, StandardCopyOption.REPLACE_EXISTING);
80 | Files.delete(original);
81 | } else {
82 | if (Files.exists(file)) {
83 | Files.delete(file);
84 | }
85 | }
86 | } catch (IOException e) {
87 | throw new RuntimeException(e);
88 | }
89 | }
90 |
91 | @Test
92 | public void guidelineTitleStartsWithKeyword() {
93 | var guidelines = getValidator().getGuidelines().values().stream().filter(it -> it.getId() >= 9000).toList();
94 | for (final PLSQLCopGuideline g : guidelines) {
95 | assertThat('"' + g.getMsg() + "' does not start with keyword", g.getMsg(),
96 | anyOf(startsWith("Always"), startsWith("Never"), startsWith("Avoid"), startsWith("Try")));
97 | }
98 | }
99 |
100 | public XtextResource parse(String stmt) {
101 | final XtextResourceSet resourceSet = injector.getInstance(XtextResourceSet.class);
102 | resourceSet.addLoadOption(XtextResource.OPTION_RESOLVE_ALL, Boolean.TRUE);
103 | resourceSet.addLoadOption(XtextResource.OPTION_ENCODING, Charset.defaultCharset().name());
104 | final Resource resource = resourceSet.createResource(URI.createURI("dummy:/test.plsql"));
105 | final ByteArrayInputStream input = new ByteArrayInputStream(stmt.getBytes());
106 | try {
107 | resource.load(input, resourceSet.getLoadOptions());
108 | } catch (IOException e) {
109 | throw new RuntimeException(e);
110 | }
111 | return ((XtextResource) resource);
112 | }
113 |
114 | public List getIssues(String stmt) {
115 | final XtextResource resource = parse(stmt);
116 | final EList errors = resource.getErrors();
117 | if (errors.size() > 0) {
118 | final Resource.Diagnostic firstError = errors.get(0);
119 | throw new RuntimeException(
120 | "Syntax error: " + firstError.getMessage() + " at line " + firstError.getLine() + ".");
121 | }
122 | return resource.getResourceServiceProvider().getResourceValidator().validate(resource, CheckMode.ALL, null);
123 | }
124 |
125 | public PLSQLValidator getValidator() {
126 | return injector.getInstance(PLSQLValidator.class);
127 | }
128 | }
129 |
--------------------------------------------------------------------------------
/src/test/java/com/trivadis/tvdcc/validators/tests/GLPTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017 Philipp Salvisberg
3 | *
4 | * Licensed under the Creative Commons Attribution-NonCommercial-NoDerivs 3.0
5 | * Unported License (the "License"); you may not use this file except
6 | * in compliance with the License. You may obtain a copy of the License at
7 | *
8 | * https://creativecommons.org/licenses/by-nc-nd/3.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 | package com.trivadis.tvdcc.validators.tests;
17 |
18 | import com.trivadis.oracle.plsql.validation.PLSQLValidatorPreferences;
19 | import com.trivadis.tvdcc.validators.GLP;
20 |
21 | import org.junit.Assert;
22 | import org.junit.BeforeClass;
23 | import org.junit.Test;
24 |
25 | public class GLPTest extends AbstractValidatorTest {
26 |
27 | @BeforeClass
28 | public static void setupValidator() {
29 | PLSQLValidatorPreferences.INSTANCE.setValidatorClass(GLP.class);
30 | }
31 |
32 | @Test
33 | public void guidelines() {
34 | var guidelines = getValidator().getGuidelines();
35 | Assert.assertEquals(3, guidelines.values().stream().filter(it -> it.getId() >= 9000).count());
36 | }
37 |
38 | @Test
39 | public void procedureOk() {
40 | var stmt = """
41 | CREATE OR REPLACE PROCEDURE p (p_1 IN INTEGER, p_2 IN VARCHAR2) AS
42 | l_something INTEGER;
43 | BEGIN
44 | NULL;
45 | END p;
46 | """;
47 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().startsWith("G-9")).toList();
48 | Assert.assertEquals(0, issues.size());
49 | }
50 |
51 | @Test
52 | public void procedureNok() {
53 | var stmt = """
54 | CREATE OR REPLACE PROCEDURE p (a IN INTEGER, b IN VARCHAR2) AS
55 | c INTEGER;
56 | BEGIN
57 | NULL;
58 | END p;
59 | """;
60 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().startsWith("G-9")).toList();
61 | Assert.assertEquals(3, issues.size());
62 | // a
63 | var issue1 = issues.get(0);
64 | Assert.assertEquals(1, issue1.getLineNumber().intValue());
65 | Assert.assertEquals(32, issue1.getColumn().intValue());
66 | Assert.assertEquals(1, issue1.getLength().intValue());
67 | Assert.assertEquals("G-9003", issue1.getCode());
68 | Assert.assertEquals("G-9003: Always prefix parameters with 'p_'.", issue1.getMessage());
69 | Assert.assertEquals("a IN INTEGER", issue1.getData()[0]);
70 | // b
71 | var issue2 = issues.get(1);
72 | Assert.assertEquals(1, issue2.getLineNumber().intValue());
73 | Assert.assertEquals(46, issue2.getColumn().intValue());
74 | Assert.assertEquals(1, issue2.getLength().intValue());
75 | Assert.assertEquals("G-9003", issue2.getCode());
76 | Assert.assertEquals("G-9003: Always prefix parameters with 'p_'.", issue2.getMessage());
77 | Assert.assertEquals("b IN VARCHAR2", issue2.getData()[0]);
78 | // c
79 | var issue3 = issues.get(2);
80 | Assert.assertEquals(2, issue3.getLineNumber().intValue());
81 | Assert.assertEquals(4, issue3.getColumn().intValue());
82 | Assert.assertEquals(1, issue3.getLength().intValue());
83 | Assert.assertEquals("G-9002", issue3.getCode());
84 | Assert.assertEquals("G-9002: Always prefix local variables with 'l_'.", issue3.getMessage());
85 | Assert.assertEquals("c INTEGER;", issue3.getData()[0]);
86 | }
87 |
88 | @Test
89 | public void packageBodyOk() {
90 | var stmt = """
91 | CREATE OR REPLACE PACKAGE BODY pkg AS
92 | g_global_variable INTEGER;
93 |
94 | PROCEDURE p (
95 | p_parameter1 IN INTEGER,
96 | p_parameter2 IN VARCHAR2
97 | ) AS
98 | l_local_variable INTEGER;
99 | BEGIN
100 | NULL;
101 | END p;
102 |
103 | FUNCTION f (
104 | p_parameter1 IN INTEGER,
105 | p_parameter2 IN INTEGER
106 | ) RETURN INTEGER AS
107 | l_local_variable INTEGER;
108 | BEGIN
109 | RETURN p_parameter1 * p_parameter2;
110 | END f;
111 | END pkg;
112 | """;
113 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().startsWith("G-9")).toList();
114 | Assert.assertEquals(0, issues.size());
115 | }
116 |
117 | @Test
118 | public void packageBodyNok() {
119 | var stmt = """
120 | CREATE OR REPLACE PACKAGE BODY pkg AS
121 | global_variable INTEGER;
122 |
123 | PROCEDURE p (
124 | parameter1 IN INTEGER,
125 | parameter2 IN VARCHAR2
126 | ) AS
127 | local_variable INTEGER;
128 | BEGIN
129 | NULL;
130 | END p;
131 |
132 | FUNCTION f (
133 | parameter1 IN INTEGER,
134 | parameter2 IN INTEGER
135 | ) RETURN INTEGER AS
136 | local_variable INTEGER;
137 | BEGIN
138 | RETURN parameter1 * p_parameter2;
139 | END f;
140 | END pkg;
141 | """;
142 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().startsWith("G-9")).toList();
143 | Assert.assertEquals(7, issues.size());
144 | // global_variable
145 | var issue1 = issues.get(0);
146 | Assert.assertEquals(2, issue1.getLineNumber().intValue());
147 | Assert.assertEquals(4, issue1.getColumn().intValue());
148 | Assert.assertEquals(15, issue1.getLength().intValue());
149 | Assert.assertEquals("G-9001", issue1.getCode());
150 | Assert.assertEquals("G-9001: Always prefix global variables with 'g_'.", issue1.getMessage());
151 | Assert.assertEquals("global_variable INTEGER;", issue1.getData()[0]);
152 | }
153 | }
154 |
--------------------------------------------------------------------------------
/src/test/java/com/trivadis/tvdcc/validators/tests/OverrideTrivadisGuidelinesTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2019 Philipp Salvisberg
3 | *
4 | * Licensed under the Creative Commons Attribution-NonCommercial-NoDerivs 3.0
5 | * Unported License (the "License"); you may not use this file except
6 | * in compliance with the License. You may obtain a copy of the License at
7 | *
8 | * https://creativecommons.org/licenses/by-nc-nd/3.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 | package com.trivadis.tvdcc.validators.tests;
17 |
18 | import com.trivadis.oracle.plsql.validation.PLSQLValidatorPreferences;
19 | import com.trivadis.tvdcc.validators.OverrideTrivadisGuidelines;
20 | import org.junit.Assert;
21 | import org.junit.BeforeClass;
22 | import org.junit.Test;
23 |
24 | public class OverrideTrivadisGuidelinesTest extends AbstractValidatorTest {
25 |
26 | @BeforeClass
27 | public static void setupValidator() {
28 | PLSQLValidatorPreferences.INSTANCE.setValidatorClass(OverrideTrivadisGuidelines.class);
29 | }
30 |
31 | @Test
32 | public void literalInConstantDeclarationsIsOkay() {
33 | var stmt = """
34 | CREATE PACKAGE pkg AS
35 | co_templ CONSTANT VARCHAR2(4000 BYTE) := 'a text' || ' more text';
36 | END pkg;
37 | """;
38 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().equals("G-1050")).toList();
39 | Assert.assertEquals(0, issues.size());
40 | }
41 |
42 | @Test
43 | public void literalInLoggerCallIsOkay() {
44 | var stmt = """
45 | BEGIN
46 | logger.log('Hello World');
47 | END;
48 | """;
49 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().equals("G-1050")).toList();
50 | Assert.assertEquals(0, issues.size());
51 | }
52 |
53 | @Test
54 | public void literalInFunctionOfLoggerCallIsOkay() {
55 | var stmt = """
56 | BEGIN
57 | logger.log(upper('Hello World'));
58 | logger.log(upper('Hello World'));
59 | END;
60 | """;
61 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().equals("G-1050")).toList();
62 | Assert.assertEquals(0, issues.size());
63 | }
64 |
65 | @Test
66 | public void literalInPackageFunctionOfLoggerCallIsOkay() {
67 | var stmt = """
68 | BEGIN
69 | logger.log(x.y('Hello World'));
70 | logger.log(x.y('Hello World'));
71 | END;
72 | """;
73 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().equals("G-1050")).toList();
74 | Assert.assertEquals(0, issues.size());
75 | }
76 |
77 | @Test
78 | public void literalInDbmsOutputCallIsNotOkay() {
79 | var stmt = """
80 | BEGIN
81 | dbms_output.put_line('Hello World');
82 | dbms_output.put_line('Hello World');
83 | END;
84 | """;
85 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().equals("G-1050")).toList();
86 | Assert.assertEquals(2, issues.size());
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/src/test/java/com/trivadis/tvdcc/validators/tests/TrivadisGuidelines3PlusTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2020 Philipp Salvisberg
3 | *
4 | * Licensed under the Creative Commons Attribution-NonCommercial-NoDerivs 3.0
5 | * Unported License (the "License"); you may not use this file except
6 | * in compliance with the License. You may obtain a copy of the License at
7 | *
8 | * https://creativecommons.org/licenses/by-nc-nd/3.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 | package com.trivadis.tvdcc.validators.tests;
17 |
18 | import com.trivadis.oracle.plsql.validation.PLSQLValidatorPreferences;
19 | import com.trivadis.tvdcc.validators.TrivadisGuidelines3Plus;
20 | import org.junit.Assert;
21 | import org.junit.BeforeClass;
22 | import org.junit.Test;
23 |
24 | public class TrivadisGuidelines3PlusTest extends AbstractValidatorTest {
25 |
26 | @BeforeClass
27 | public static void setupValidator() {
28 | PLSQLValidatorPreferences.INSTANCE.setValidatorClass(TrivadisGuidelines3Plus.class);
29 | }
30 |
31 | @Test
32 | public void guidelines() {
33 | var guidelines = getValidator().getGuidelines();
34 | Assert.assertEquals(22, guidelines.values().stream().filter(it -> it.getId() >= 9100).toList().size()); // last guideline in v4.2 is G-9040
35 | Assert.assertEquals(125, guidelines.values().stream().filter(it -> it.getId() < 9100).toList().size()); // added G-3182, G-3183 in v4.3, added G-3330, G-4387 in v4.4
36 | Assert.assertEquals(79, guidelines.values().stream().filter(it -> it.getId() < 1000).toList().size());
37 | }
38 |
39 | @Test
40 | public void getGuidelineId_mapped_via_Trivadis2() {
41 | Assert.assertEquals("G-1010", getValidator().getGuidelineId(1));
42 | }
43 |
44 | @Test
45 | public void getGuidelineId_of_Trivadis3() {
46 | Assert.assertEquals("G-2130", getValidator().getGuidelineId(2130));
47 | }
48 |
49 | @Test
50 | public void getGuidelineMsg_mapped_via_Trivadis2() {
51 | Assert.assertEquals("G-1010: Try to label your sub blocks.", getValidator().getGuidelineMsg(1));
52 | }
53 |
54 | @Test
55 | public void getGuidelineMsg_mapped_via_Trivadis3() {
56 | Assert.assertEquals("G-2130: Try to use subtypes for constructs used often in your code.",
57 | getValidator().getGuidelineMsg(2130));
58 | }
59 |
60 | // issue avoided by OverrideTrivadisGuidelines (would throw an error via TrivadisGuidelines3)
61 | @Test
62 | public void literalInLoggerCallIsOkay() {
63 | var stmt = """
64 | BEGIN
65 | logger.log('Hello World');
66 | END;
67 | """;
68 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().equals("G-1050")).toList();
69 | Assert.assertEquals(0, issues.size());
70 | }
71 |
72 | // issue thrown by OverrideTrivadisGuidelines (check in parent)
73 | @Test
74 | public void literalInDbmsOutputCallIsNotOkay() {
75 | var stmt = """
76 | BEGIN
77 | dbms_output.put_line('Hello World');
78 | dbms_output.put_line('Hello World');
79 | END;
80 | """;
81 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().equals("G-1050")).toList();
82 | Assert.assertEquals(2, issues.size());
83 | }
84 |
85 | // issue thrown by TrivadisGuidelines3
86 | @Test
87 | public void guideline2230_na() {
88 | var stmt = """
89 | CREATE OR REPLACE PACKAGE BODY constants_up IS
90 | co_big_increase CONSTANT NUMBER(5,0) := 1;
91 |
92 | FUNCTION big_increase RETURN NUMBER DETERMINISTIC IS
93 | BEGIN
94 | RETURN co_big_increase;
95 | END big_increase;
96 | END constants_up;
97 | /
98 | """;
99 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().equals("G-2230")).toList();
100 | Assert.assertEquals(1, issues.size());
101 | }
102 |
103 | // issue thrown by TrivadisGuidelines2
104 | @Test
105 | public void guideline1010_10() {
106 | var stmt = """
107 | BEGIN
108 | BEGIN
109 | NULL;
110 | END;
111 | END;
112 | /
113 | """;
114 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().equals("G-1010")).toList();
115 | Assert.assertEquals(1, issues.size());
116 | }
117 |
118 | // issue thrown by SQLInjection
119 | @Test
120 | public void executeImmediateNotAssertedVariable() {
121 | var stmt = """
122 | CREATE OR REPLACE PROCEDURE p (in_table_name IN VARCHAR2) AS
123 | co_templ CONSTANT VARCHAR2(4000 BYTE) := 'DROP TABLE #in_table_name# PURGE';
124 | l_table_name VARCHAR2(128 BYTE);
125 | l_sql VARCHAR2(4000 BYTE);
126 | BEGIN
127 | l_table_name := in_table_name;
128 | l_sql := replace(l_templ, '#in_table_name#', l_table_name);
129 | EXECUTE IMMEDIATE l_sql;
130 | END p;
131 | """;
132 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().equals("G-9501")).toList();
133 | Assert.assertEquals(1, issues.size());
134 | }
135 |
136 | // issue thrown by TrivadisPlsqlNaming
137 | @Test
138 | public void globalVariableNok() {
139 | var stmt = """
140 | CREATE OR REPLACE PACKAGE example AS
141 | some_name INTEGER;
142 | END example;
143 | /
144 | """;
145 | var issues = getIssues(stmt);
146 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9101")).toList().size());
147 | }
148 |
149 | // issue thrown by Hint
150 | @Test
151 | public void unknownHint() {
152 | var stmt = """
153 | INSERT /*+ NOLOGGING APPEND */ INTO sales_hist SELECT * FROM sales;
154 | """;
155 | var issues = getIssues(stmt);
156 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9601")).toList().size());
157 | }
158 | }
159 |
--------------------------------------------------------------------------------
/src/test/java/com/trivadis/tvdcc/validators/tests/TrivadisPlsqlNamingPropertiesFileTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2020 Philipp Salvisberg
3 | *
4 | * Licensed under the Creative Commons Attribution-NonCommercial-NoDerivs 3.0
5 | * Unported License (the "License"); you may not use this file except
6 | * in compliance with the License. You may obtain a copy of the License at
7 | *
8 | * https://creativecommons.org/licenses/by-nc-nd/3.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 | package com.trivadis.tvdcc.validators.tests;
17 |
18 | import com.trivadis.oracle.plsql.validation.PLSQLValidatorPreferences;
19 | import com.trivadis.tvdcc.validators.TrivadisPlsqlNaming;
20 | import java.io.BufferedWriter;
21 | import java.io.File;
22 | import java.io.FileWriter;
23 | import java.io.IOException;
24 | import org.junit.Assert;
25 | import org.junit.BeforeClass;
26 | import org.junit.Test;
27 |
28 | public class TrivadisPlsqlNamingPropertiesFileTest extends AbstractValidatorTest {
29 |
30 | @BeforeClass
31 | public static void commonSetup() {
32 | stashPropertiesFile();
33 | createTestPropertiesFile();
34 | PLSQLValidatorPreferences.INSTANCE.setValidatorClass(TrivadisPlsqlNaming.class);
35 | }
36 |
37 | // create a simple properties file to test with
38 | public static void createTestPropertiesFile() {
39 | try {
40 | final File file = new File(FULL_PROPERTIES_FILE_NAME);
41 | final FileWriter fileWriter = new FileWriter(file, true);
42 | final BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
43 | bufferedWriter.write("REGEX_LOCAL_VARIABLE_NAME = ^loc_.+$");
44 | bufferedWriter.newLine();
45 | bufferedWriter.close();
46 | fileWriter.close();
47 | } catch (IOException e) {
48 | throw new RuntimeException(e);
49 | }
50 | }
51 |
52 | // check that old prefix is now not accepted
53 | @Test
54 | public void LocalVariableNok() {
55 | var stmt = """
56 | CREATE OR REPLACE PACKAGE BODY example AS
57 | PROCEDURE a IS
58 | l_some_name INTEGER;
59 | BEGIN
60 | NULL;
61 | END a;
62 | END example;
63 | """;
64 | var issues = getIssues(stmt);
65 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9102")).toList().size());
66 | }
67 |
68 | // check that new prefix from file is accepted
69 | @Test
70 | public void LocalVariableOk() {
71 | var stmt = """
72 | CREATE OR REPLACE PACKAGE BODY example AS
73 | PROCEDURE a IS
74 | loc_some_name INTEGER;
75 | BEGIN
76 | NULL;
77 | END a;
78 | END example;
79 | """;
80 | var issues = getIssues(stmt);
81 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9102")).toList().size());
82 | }
83 |
84 | // check that defaults are used if not specified in the properties-file
85 | @Test
86 | public void GlobalVariableNok() {
87 | var stmt = """
88 | CREATE OR REPLACE PACKAGE example AS
89 | some_name INTEGER;
90 | END example;
91 | /
92 | """;
93 | var issues = getIssues(stmt);
94 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9101")).toList().size());
95 | }
96 |
97 | // check that defaults are used if not specified in the properties-file
98 | @Test
99 | public void GlobalVariableOk() {
100 | var stmt = """
101 | CREATE OR REPLACE PACKAGE example AS
102 | g_some_name INTEGER;
103 | END example;
104 | """;
105 | var issues = getIssues(stmt);
106 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9101")).toList().size());
107 | }
108 | }
109 |
--------------------------------------------------------------------------------
/src/test/java/com/trivadis/tvdcc/validators/tests/TrivadisPlsqlNamingSystemPropertiesTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2024 Philipp Salvisberg
3 | *
4 | * Licensed under the Creative Commons Attribution-NonCommercial-NoDerivs 3.0
5 | * Unported License (the "License"); you may not use this file except
6 | * in compliance with the License. You may obtain a copy of the License at
7 | *
8 | * https://creativecommons.org/licenses/by-nc-nd/3.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 | package com.trivadis.tvdcc.validators.tests;
17 |
18 | import com.trivadis.oracle.plsql.validation.PLSQLValidatorPreferences;
19 | import com.trivadis.tvdcc.validators.TrivadisPlsqlNaming;
20 | import java.io.File;
21 | import org.junit.Assert;
22 | import org.junit.BeforeClass;
23 | import org.junit.Test;
24 |
25 | public class TrivadisPlsqlNamingSystemPropertiesTest extends AbstractValidatorTest {
26 |
27 | @BeforeClass
28 | public static void commonSetup() {
29 | stashPropertiesFile();
30 | removePropertiesFile();
31 | System.getProperties().setProperty("REGEX_LOCAL_VARIABLE_NAME", "^local_.+$");
32 | PLSQLValidatorPreferences.INSTANCE.setValidatorClass(TrivadisPlsqlNaming.class);
33 | }
34 |
35 | // remove property file to ensure it cannot be read from the validator
36 | public static void removePropertiesFile() {
37 | final File file = new File(FULL_PROPERTIES_FILE_NAME);
38 | file.delete();
39 | }
40 |
41 | // check that old prefix is now not accepted
42 | @Test
43 | public void LocalVariableNok() {
44 | var stmt = """
45 | CREATE OR REPLACE PACKAGE BODY example AS
46 | PROCEDURE a IS
47 | l_some_name INTEGER;
48 | BEGIN
49 | NULL;
50 | END a;
51 | END example;
52 | """;
53 | var issues = getIssues(stmt);
54 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9102")).toList().size());
55 | }
56 |
57 | // check that new prefix from file is accepted
58 | @Test
59 | public void LocalVariableOk() {
60 | var stmt = """
61 | CREATE OR REPLACE PACKAGE BODY example AS
62 | PROCEDURE a IS
63 | local_some_name INTEGER;
64 | BEGIN
65 | NULL;
66 | END a;
67 | END example;
68 | """;
69 | var issues = getIssues(stmt);
70 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9102")).toList().size());
71 | }
72 |
73 | // check that defaults are used if not specified in the properties-file
74 | @Test
75 | public void GlobalVariableNok() {
76 | var stmt = """
77 | CREATE OR REPLACE PACKAGE example AS
78 | some_name INTEGER;
79 | END example;
80 | /
81 | """;
82 | var issues = getIssues(stmt);
83 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9101")).toList().size());
84 | }
85 |
86 | // check that defaults are used if not specified in the properties-file
87 | @Test
88 | public void GlobalVariableOk() {
89 | var stmt = """
90 | CREATE OR REPLACE PACKAGE example AS
91 | g_some_name INTEGER;
92 | END example;
93 | """;
94 | var issues = getIssues(stmt);
95 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9101")).toList().size());
96 | }
97 | }
98 |
--------------------------------------------------------------------------------
/src/test/java/com/trivadis/tvdcc/validators/tests/TrivadisPlsqlNamingTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2017 Philipp Salvisberg
3 | *
4 | * Licensed under the Creative Commons Attribution-NonCommercial-NoDerivs 3.0
5 | * Unported License (the "License"); you may not use this file except
6 | * in compliance with the License. You may obtain a copy of the License at
7 | *
8 | * https://creativecommons.org/licenses/by-nc-nd/3.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 | package com.trivadis.tvdcc.validators.tests;
17 |
18 | import com.trivadis.oracle.plsql.validation.PLSQLValidatorPreferences;
19 | import com.trivadis.tvdcc.validators.TrivadisPlsqlNaming;
20 | import org.junit.Assert;
21 | import org.junit.BeforeClass;
22 | import org.junit.Test;
23 |
24 | public class TrivadisPlsqlNamingTest extends AbstractValidatorTest {
25 |
26 | @BeforeClass
27 | public static void setupValidator() {
28 | PLSQLValidatorPreferences.INSTANCE.setValidatorClass(TrivadisPlsqlNaming.class);
29 | }
30 |
31 | @Test
32 | public void globalVariableNok() {
33 | var stmt = """
34 | CREATE OR REPLACE PACKAGE example AS
35 | some_name INTEGER;
36 | END example;
37 | /
38 | """;
39 | var issues = getIssues(stmt);
40 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9101")).toList().size());
41 | }
42 |
43 | @Test
44 | public void globalVariableOk() {
45 | var stmt = """
46 | CREATE OR REPLACE PACKAGE example AS
47 | g_some_name INTEGER;
48 | END example;
49 | """;
50 | var issues = getIssues(stmt);
51 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9101")).toList().size());
52 | }
53 |
54 | @Test
55 | public void localVariableNok() {
56 | var stmt = """
57 | CREATE OR REPLACE PACKAGE BODY example AS
58 | PROCEDURE a IS
59 | some_name INTEGER;
60 | BEGIN
61 | NULL;
62 | END a;
63 | END example;
64 | """;
65 | var issues = getIssues(stmt);
66 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9102")).toList().size());
67 | }
68 |
69 | @Test
70 | public void localVariableOk() {
71 | var stmt = """
72 | CREATE OR REPLACE PACKAGE BODY example AS
73 | PROCEDURE a IS
74 | l_some_name INTEGER;
75 | BEGIN
76 | NULL;
77 | END a;
78 | END example;
79 | """;
80 | var issues = getIssues(stmt);
81 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9102")).toList().size());
82 | }
83 |
84 | @Test
85 | public void localVariableForStrongCursorOk() {
86 | var stmt = """
87 | declare
88 | type c_emp_type is ref cursor return employees%rowtype;
89 | c_emp c_emp_type;
90 | r_emp employees%rowtype;
91 | begin
92 | open c_emp for select * from employees where employee_id = 100;
93 | fetch c_emp into r_emp;
94 | close c_emp;
95 | sys.dbms_output.put_line('first_name: ' || r_emp.first_name);
96 | end;
97 | """;
98 | var issues = getIssues(stmt);
99 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9102")).toList().size());
100 | }
101 |
102 | @Test
103 | public void localVariableForObjectOk() {
104 | var stmt = """
105 | declare
106 | o_game game_ot;
107 | begin
108 | o_game := game_ot();
109 | pkg.proc(o_game);
110 | end;
111 | """;
112 | var issues = getIssues(stmt);
113 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9102")).toList().size());
114 | }
115 |
116 | @Test
117 | public void localVariableForArrayOk() {
118 | var stmt = """
119 | declare
120 | t_words word_ct;
121 | begin
122 | t_words := word_ct();
123 | pkg.proc(t_words);
124 | end;
125 | """;
126 | var issues = getIssues(stmt);
127 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9102")).toList().size());
128 | }
129 |
130 | @Test
131 | public void localVariableSingleLetterIOk() {
132 | // use as common index "i" is accepted
133 | var stmt = """
134 | declare
135 | i pls_integer := 0;
136 | begin
137 | while i < 10
138 | loop
139 | dbms_output.put_line(i);
140 | i := i + 1;
141 | end loop;
142 | end;
143 | """;
144 | var issues = getIssues(stmt);
145 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9102")).toList().size());
146 | }
147 |
148 | @Test
149 | public void localVariableSingleLetterJOk() {
150 | // use as common index "j" is accepted
151 | var stmt = """
152 | declare
153 | j pls_integer := 0;
154 | begin
155 | while j < 10
156 | loop
157 | dbms_output.put_line(j);
158 | j := j + 1;
159 | end loop;
160 | end;
161 | """;
162 | var issues = getIssues(stmt);
163 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9102")).toList().size());
164 | }
165 |
166 | @Test
167 | public void cursorNameNok() {
168 | var stmt = """
169 | DECLARE
170 | CURSOR some_name IS SELECT * FROM emp;
171 | BEGIN
172 | NULL;
173 | END;
174 | """;
175 | var issues = getIssues(stmt);
176 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9103")).toList().size());
177 | }
178 |
179 | @Test
180 | public void cursorNameOk() {
181 | var stmt = """
182 | DECLARE
183 | CURSOR c_some_name IS SELECT * FROM emp;
184 | BEGIN
185 | NULL;
186 | END;
187 | """;
188 | var issues = getIssues(stmt);
189 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9103")).toList().size());
190 | }
191 |
192 | @Test
193 | public void sysrefcursorNameNOk_bug5() {
194 | var stmt = """
195 | DECLARE
196 | l_dept SYS_REFCURSOR;
197 | BEGIN
198 | NULL;
199 | END;
200 | /
201 | """;
202 | var issues = getIssues(stmt);
203 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9103")).toList().size());
204 | }
205 |
206 | @Test
207 | public void sysrefcursorNameOk_bug5() {
208 | var stmt = """
209 | DECLARE
210 | c_dept SYS_REFCURSOR;
211 | BEGIN
212 | NULL;
213 | END;
214 | /
215 | """;
216 | var issues = getIssues(stmt);
217 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9103")).toList().size());
218 | }
219 |
220 | @Test
221 | public void recordNameNok() {
222 | var stmt = """
223 | DECLARE
224 | emp emp%ROWTYPE;
225 | TYPE r_dept_type IS RECORD (
226 | deptno NUMBER,
227 | dname VARCHAR2(14 CHAR),
228 | loc LOC(13 CHAR)
229 | );
230 | dept r_dept_type;
231 | BEGIN
232 | NULL;
233 | END;
234 | """;
235 | var issues = getIssues(stmt);
236 | Assert.assertEquals(2, issues.stream().filter(it -> it.getCode().equals("G-9104")).toList().size());
237 | }
238 |
239 | @Test
240 | public void recordNameOk() {
241 | var stmt = """
242 | DECLARE
243 | r_emp emp%ROWTYPE;
244 | TYPE r_dept_type IS RECORD (
245 | deptno NUMBER,
246 | dname VARCHAR2(14 CHAR),
247 | loc LOC(13 CHAR)
248 | );
249 | r_dept r_dept_type;
250 | BEGIN
251 | NULL;
252 | END;
253 | """;
254 | var issues = getIssues(stmt);
255 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9104")).toList().size());
256 | }
257 |
258 | @Test
259 | public void arrayNameNok() {
260 | var stmt = """
261 | DECLARE
262 | TYPE t_varray_type IS VARRAY(10) OF STRING;
263 | array1 t_varray_type;
264 | TYPE t_nested_table_type IS TABLE OF STRING;
265 | array2 t_nested_table_type;
266 | TYPE t_assoc_array_type IS TABLE OF STRING INDEX BY PLS_INTEGER;
267 | array3 t_assoc_array_type;
268 | BEGIN
269 | NULL;
270 | END;
271 | """;
272 | var issues = getIssues(stmt);
273 | Assert.assertEquals(3, issues.stream().filter(it -> it.getCode().equals("G-9105")).toList().size());
274 | }
275 |
276 | @Test
277 | public void arrayNameOk() {
278 | var stmt = """
279 | DECLARE
280 | TYPE t_varray_type IS VARRAY(10) OF STRING;
281 | t_array1 t_varray_type;
282 | TYPE t_nested_table_type IS TABLE OF STRING;
283 | t_array2 t_nested_table_type;
284 | TYPE t_assoc_array_type IS TABLE OF STRING INDEX BY PLS_INTEGER;
285 | t_array3 t_assoc_array_type;
286 | BEGIN
287 | NULL;
288 | END;
289 | """;
290 | var issues = getIssues(stmt);
291 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9105")).toList().size());
292 | }
293 |
294 | @Test
295 | public void objectNameNok() {
296 | var stmt = """
297 | CREATE OR REPLACE TYPE dept_type AS OBJECT (
298 | deptno INTEGER,
299 | dname VARCHAR2(14 CHAR),
300 | loc VARCHAR2(13 CHAR)
301 | );
302 |
303 | DECLARE
304 | dept dept_type;
305 | BEGIN
306 | NULL;
307 | END;
308 | """;
309 | var issues = getIssues(stmt);
310 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9106")).toList().size());
311 | }
312 |
313 | @Test
314 | public void objectNameOk() {
315 | var stmt = """
316 | CREATE OR REPLACE TYPE dept_type AS OBJECT (
317 | deptno INTEGER,
318 | dname VARCHAR2(14 CHAR),
319 | loc VARCHAR2(13 CHAR)
320 | );
321 |
322 | DECLARE
323 | o_dept dept_type;
324 | BEGIN
325 | NULL;
326 | END;
327 | """;
328 | var issues = getIssues(stmt);
329 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9106")).toList().size());
330 | }
331 |
332 | @Test
333 | public void cursorParameterNameNok() {
334 | var stmt = """
335 | DECLARE
336 | CURSOR c_emp (x_ename IN VARCHAR2) IS
337 | SELECT *
338 | FROM emp
339 | WHERE ename LIKE x_ename;
340 | BEGIN
341 | NULL;
342 | END;
343 | """;
344 | var issues = getIssues(stmt);
345 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9107")).toList().size());
346 | }
347 |
348 | @Test
349 | public void cursorParameterNameOk() {
350 | var stmt = """
351 | DECLARE
352 | CURSOR c_emp (p_ename IN VARCHAR2) IS
353 | SELECT *
354 | FROM emp
355 | WHERE ename LIKE p_ename;
356 | BEGIN
357 | NULL;
358 | END;
359 | """;
360 | var issues = getIssues(stmt);
361 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9107")).toList().size());
362 | }
363 |
364 | @Test
365 | public void inParameterNameNok() {
366 | var stmt = """
367 | CREATE PROCEDURE p1 (param INTEGER) IS
368 | BEGIN
369 | NULL;
370 | END p1;
371 |
372 | CREATE PACKAGE p IS
373 | PROCEDURE p2 (param IN INTEGER);
374 | END p;
375 | """;
376 | var issues = getIssues(stmt);
377 | Assert.assertEquals(2, issues.stream().filter(it -> it.getCode().equals("G-9108")).toList().size());
378 | }
379 |
380 | @Test
381 | public void inParameterNameOk() {
382 | var stmt = """
383 | CREATE PROCEDURE p1 (in_param INTEGER) IS
384 | BEGIN
385 | NULL;
386 | END p1;
387 |
388 | CREATE PACKAGE p IS
389 | PROCEDURE p2 (in_param IN INTEGER);
390 | END p;
391 | """;
392 | var issues = getIssues(stmt);
393 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9108")).toList().size());
394 | }
395 |
396 | @Test
397 | public void SelfInParameterNameOk() {
398 | var stmt = """
399 | CREATE OR REPLACE TYPE rectangle AUTHID definer AS OBJECT (
400 | rect_length NUMBER,
401 | rect_width NUMBER,
402 | member FUNCTION get_surface (
403 | self IN rectangle
404 | ) RETURN NUMBER
405 | );
406 | """;
407 | var issues = getIssues(stmt);
408 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9108")).toList().size());
409 | }
410 |
411 | @Test
412 | public void outParameterNameNok() {
413 | var stmt = """
414 | CREATE PROCEDURE p1 (param OUT INTEGER) IS
415 | BEGIN
416 | NULL;
417 | END p1;
418 |
419 | CREATE PACKAGE p IS
420 | PROCEDURE p2 (param OUT INTEGER);
421 | END p;
422 | """;
423 | var issues = getIssues(stmt);
424 | Assert.assertEquals(2, issues.stream().filter(it -> it.getCode().equals("G-9109")).toList().size());
425 | }
426 |
427 | @Test
428 | public void outParameterNameOk() {
429 | var stmt = """
430 | CREATE PROCEDURE p1 (out_param OUT INTEGER) IS
431 | BEGIN
432 | NULL;
433 | END p1;
434 |
435 | CREATE PACKAGE p IS
436 | PROCEDURE p2 (out_param OUT INTEGER);
437 | END p;
438 | """;
439 | var issues = getIssues(stmt);
440 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9109")).toList().size());
441 | }
442 |
443 | @Test
444 | public void inOutParameterNameNok() {
445 | var stmt = """
446 | CREATE PROCEDURE p1 (param IN OUT INTEGER) IS
447 | BEGIN
448 | NULL;
449 | END p1;
450 |
451 | CREATE PACKAGE p IS
452 | PROCEDURE p2 (param IN OUT INTEGER);
453 | END p;
454 | """;
455 | var issues = getIssues(stmt);
456 | Assert.assertEquals(2, issues.stream().filter(it -> it.getCode().equals("G-9110")).toList().size());
457 | }
458 |
459 | @Test
460 | public void inOutParameterNameOk() {
461 | var stmt = """
462 | CREATE PROCEDURE p1 (io_param IN OUT INTEGER) IS
463 | BEGIN
464 | NULL;
465 | END p1;
466 |
467 | CREATE PACKAGE p IS
468 | PROCEDURE p2 (io_param IN OUT INTEGER);
469 | END p;
470 | """;
471 | var issues = getIssues(stmt);
472 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9110")).toList().size());
473 | }
474 |
475 | @Test
476 | public void SelfInOutParameterNameOk() {
477 | var stmt = """
478 | CREATE OR REPLACE TYPE rectangle AUTHID definer AS OBJECT (
479 | rect_length NUMBER,
480 | rect_width NUMBER,
481 | CONSTRUCTOR FUNCTION rectangle (
482 | self IN OUT NOCOPY rectangle,
483 | in_length_and_width IN NUMBER
484 | ) RETURN SELF AS RESULT
485 | );
486 | """;
487 | var issues = getIssues(stmt);
488 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9110")).toList().size());
489 | }
490 |
491 | @Test
492 | public void recordTypeNameNok() {
493 | var stmt = """
494 | DECLARE
495 | TYPE dept_typ IS RECORD (
496 | deptno NUMBER,
497 | dname VARCHAR2(14 CHAR),
498 | loc LOC(13 CHAR)
499 | );
500 | BEGIN
501 | NULL;
502 | END;
503 | """;
504 | var issues = getIssues(stmt);
505 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9111")).toList().size());
506 | }
507 |
508 | @Test
509 | public void recordTypeNameOk() {
510 | var stmt = """
511 | DECLARE
512 | TYPE r_dept_type IS RECORD (
513 | deptno NUMBER,
514 | dname VARCHAR2(14 CHAR),
515 | loc LOC(13 CHAR)
516 | );
517 | BEGIN
518 | NULL;
519 | END;
520 | """;
521 | var issues = getIssues(stmt);
522 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9111")).toList().size());
523 | }
524 |
525 | @Test
526 | public void arrayTypeNameNok() {
527 | var stmt = """
528 | DECLARE
529 | TYPE t_varray IS VARRAY(10) OF STRING;
530 | TYPE nested_table_type IS TABLE OF STRING;
531 | TYPE x_assoc_array_y IS TABLE OF STRING INDEX BY PLS_INTEGER;
532 | BEGIN
533 | NULL;
534 | END;
535 | """;
536 | var issues = getIssues(stmt);
537 | Assert.assertEquals(3, issues.stream().filter(it -> it.getCode().equals("G-9112")).toList().size());
538 | }
539 |
540 | @Test
541 | public void arrayTypeNameOk() {
542 | var stmt = """
543 | DECLARE
544 | TYPE t_varray_type IS VARRAY(10) OF STRING;
545 | TYPE t_nested_table_type IS TABLE OF STRING;
546 | TYPE t_assoc_array_type IS TABLE OF STRING INDEX BY PLS_INTEGER;
547 | BEGIN
548 | NULL;
549 | END;
550 | """;
551 | var issues = getIssues(stmt);
552 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9112")).toList().size());
553 |
554 | }
555 |
556 | @Test
557 | public void exceptionNameNok() {
558 | var stmt = """
559 | DECLARE
560 | some_name EXCEPTION;
561 | BEGIN
562 | NULL;
563 | END;
564 | """;
565 | var issues = getIssues(stmt);
566 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9113")).toList().size());
567 | }
568 |
569 | @Test
570 | public void exceptionNameOk() {
571 | var stmt = """
572 | DECLARE
573 | e_some_name EXCEPTION;
574 | BEGIN
575 | NULL;
576 | END;
577 | """;
578 | var issues = getIssues(stmt);
579 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9113")).toList().size());
580 | }
581 |
582 | @Test
583 | public void constantNameNok() {
584 | var stmt = """
585 | DECLARE
586 | maximum CONSTANT INTEGER := 1000;
587 | BEGIN
588 | NULL;
589 | END;
590 | """;
591 | var issues = getIssues(stmt);
592 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9114")).toList().size());
593 | }
594 |
595 | @Test
596 | public void constantNameOk() {
597 | var stmt = """
598 | DECLARE
599 | co_maximum CONSTANT INTEGER := 1000;
600 | BEGIN
601 | NULL;
602 | END;
603 | """;
604 | var issues = getIssues(stmt);
605 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9114")).toList().size());
606 | }
607 |
608 | @Test
609 | public void subtypeNameNok() {
610 | var stmt = """
611 | DECLARE
612 | SUBTYPE short_text IS VARCHAR2(100 CHAR);
613 | BEGIN
614 | NULL;
615 | END;
616 | """;
617 | var issues = getIssues(stmt);
618 | Assert.assertEquals(1, issues.stream().filter(it -> it.getCode().equals("G-9115")).toList().size());
619 | }
620 |
621 | @Test
622 | public void subtypeNameOk() {
623 | var stmt = """
624 | DECLARE
625 | SUBTYPE short_text_type IS VARCHAR2(100 CHAR);
626 | BEGIN
627 | NULL;
628 | END;
629 | """;
630 | var issues = getIssues(stmt);
631 | Assert.assertEquals(0, issues.stream().filter(it -> it.getCode().equals("G-9115")).toList().size());
632 | }
633 |
634 | // issue 62 https://github.com/Trivadis/plsql-cop-validators/issues/62
635 |
636 | @Test
637 | public void ignorelocalVariableInBasicLoopExitCondition() {
638 | var stmt = """
639 | declare
640 | a integer := 0; -- violates G-2185, not used in while loop condition nor exit condition, violates G-9102
641 | b integer; -- does not violate G-2185, used in exit condition, violates G-9102
642 | begin
643 | <>
644 | loop
645 | b := a;
646 | exit demo when b = 10;
647 | a := a + 1;
648 | end loop demo;
649 | end;
650 | /
651 | """;
652 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().equals("G-9102")).toList();
653 | Assert.assertEquals(1, issues.size());
654 | Assert.assertEquals(2, issues.get(0).getLineNumber().intValue());
655 | }
656 |
657 | @Test
658 | public void ignorelocalVariableInWhileLoopCondition() {
659 | var stmt = """
660 | declare
661 | a pls_integer := 0;
662 | b integer;
663 | begin
664 | while a < 10
665 | loop
666 | b := a;
667 | dbms_output.put_line(b);
668 | a := a + 1;
669 | end loop;
670 | end;
671 | """;
672 | var issues = getIssues(stmt).stream().filter(it -> it.getCode().equals("G-9102")).toList();
673 | Assert.assertEquals(1, issues.size());
674 | Assert.assertEquals(3, issues.get(0).getLineNumber().intValue());
675 | }
676 |
677 | }
678 |
--------------------------------------------------------------------------------