Revision 44198
trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.lib/org.gvsig.expressionevaluator.lib.impl/pom.xml | ||
---|---|---|
35 | 35 |
<scope>compile</scope> |
36 | 36 |
</dependency> |
37 | 37 |
<dependency> |
38 |
<groupId>org.apache.commons</groupId> |
|
39 |
<artifactId>commons-text</artifactId> |
|
40 |
<scope>compile</scope> |
|
41 |
</dependency> |
|
42 |
<dependency> |
|
38 | 43 |
<groupId>org.gvsig</groupId> |
39 | 44 |
<artifactId>${org.gvsig.fmap.geometry.impl}</artifactId> |
40 | 45 |
<scope>test</scope> |
trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.lib/org.gvsig.expressionevaluator.lib.impl/src/test/java/org/gvsig/expresionevaluator/impl/TestCodeToStringConverter.java | ||
---|---|---|
1 |
package org.gvsig.expresionevaluator.impl; |
|
2 |
|
|
3 |
import static junit.framework.Assert.assertEquals; |
|
4 |
import junit.framework.TestCase; |
|
5 |
import org.gvsig.expressionevaluator.spi.AbstractCodeToStringConverter; |
|
6 |
import org.gvsig.expressionevaluator.Code; |
|
7 |
import org.gvsig.expressionevaluator.CodeToStringConverter; |
|
8 |
import org.gvsig.expressionevaluator.Codes; |
|
9 |
import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator; |
|
10 |
import org.gvsig.expressionevaluator.ExpressionEvaluatorManager; |
|
11 |
import org.gvsig.expressionevaluator.Function; |
|
12 |
import org.gvsig.expressionevaluator.Compiler; |
|
13 |
import org.gvsig.expressionevaluator.LexicalAnalyzer; |
|
14 |
import org.gvsig.expressionevaluator.SymbolTable; |
|
15 |
import org.gvsig.expressionevaluator.impl.DefaultCompiler; |
|
16 |
import org.gvsig.expressionevaluator.impl.SQLLexicalAnalyzer; |
|
17 |
import org.gvsig.tools.library.impl.DefaultLibrariesInitializer; |
|
18 |
|
|
19 |
/** |
|
20 |
* |
|
21 |
* @author jjdelcerro |
|
22 |
*/ |
|
23 |
public class TestCodeToStringConverter extends TestCase { |
|
24 |
|
|
25 |
public TestCodeToStringConverter(String testName) { |
|
26 |
super(testName); |
|
27 |
} |
|
28 |
|
|
29 |
@Override |
|
30 |
protected void setUp() throws Exception { |
|
31 |
super.setUp(); |
|
32 |
new DefaultLibrariesInitializer().fullInitialize(); |
|
33 |
} |
|
34 |
|
|
35 |
@Override |
|
36 |
protected void tearDown() throws Exception { |
|
37 |
super.tearDown(); |
|
38 |
} |
|
39 |
|
|
40 |
// TODO add test methods here. The name must begin with 'test'. For example: |
|
41 |
// public void testHello() {} |
|
42 |
|
|
43 |
protected LexicalAnalyzer createLexicalAnalyzer() { |
|
44 |
SQLLexicalAnalyzer lexer = new SQLLexicalAnalyzer(); |
|
45 |
return lexer; |
|
46 |
} |
|
47 |
|
|
48 |
protected Compiler createCompiler() { |
|
49 |
Compiler compiler = new DefaultCompiler(); |
|
50 |
compiler.setLexicalAnalyzer(createLexicalAnalyzer()); |
|
51 |
return compiler; |
|
52 |
} |
|
53 |
|
|
54 |
private static class SimpleCodeToStringConverter extends AbstractCodeToStringConverter { |
|
55 |
|
|
56 |
public SimpleCodeToStringConverter() { |
|
57 |
super(); |
|
58 |
initFunctions(); |
|
59 |
} |
|
60 |
|
|
61 |
private void initFunctions() { |
|
62 |
ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager(); |
|
63 |
SymbolTable symbolTable = manager.getSymbolTable("SQL"); |
|
64 |
for (Function function : symbolTable.functions()) { |
|
65 |
this.addSupportedFunction(function.name()); |
|
66 |
} |
|
67 |
symbolTable = manager.getSymbolTable("OGC"); |
|
68 |
for (Function function : symbolTable.functions()) { |
|
69 |
this.addSupportedFunction(function.name()); |
|
70 |
} |
|
71 |
} |
|
72 |
|
|
73 |
@Override |
|
74 |
protected String functionToString(String functionName, Codes args) { |
|
75 |
switch (functionName.toLowerCase()) { |
|
76 |
case "date": |
|
77 |
return "DATE " + toString(args.get(0)) + " "; |
|
78 |
case "time": |
|
79 |
return "TIME " + toString(args.get(0)) + " "; |
|
80 |
case "timestamp": |
|
81 |
return "TIMESTAMP " + toString(args.get(0)) + " "; |
|
82 |
} |
|
83 |
return super.functionToString(functionName, args); |
|
84 |
} |
|
85 |
|
|
86 |
} |
|
87 |
|
|
88 |
public void testSimpleExpression() { |
|
89 |
String source = "(precio + 10) * 2 + 20 + 30 / 2"; |
|
90 |
|
|
91 |
CodeToStringConverter converter = new SimpleCodeToStringConverter(); |
|
92 |
Compiler compiler = createCompiler(); |
|
93 |
|
|
94 |
Code code = compiler.compileExpression(source); |
|
95 |
assertEquals("(((\"precio\" + 10) * 2) + 20) + (30 / 2)", converter.toString(code)); |
|
96 |
} |
|
97 |
|
|
98 |
public void testFunctionExpression1() { |
|
99 |
String source = "(precio + 10) * abs(2 + 20) + 30 / 2"; |
|
100 |
|
|
101 |
CodeToStringConverter converter = new SimpleCodeToStringConverter(); |
|
102 |
Compiler compiler = createCompiler(); |
|
103 |
|
|
104 |
Code code = compiler.compileExpression(source); |
|
105 |
assertEquals(true, converter.isValid(code)); |
|
106 |
assertEquals("((\"precio\" + 10) * (abs(2 + 20))) + (30 / 2)", converter.toString(code)); |
|
107 |
} |
|
108 |
} |
trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.lib/org.gvsig.expressionevaluator.lib.impl/src/test/java/org/gvsig/expresionevaluator/impl/TestGrammarCompiler.java | ||
---|---|---|
109 | 109 |
Compiler compiler = createCompiler(); |
110 | 110 |
|
111 | 111 |
Code code = compiler.compileExpression(source); |
112 |
assertEquals("IFF(=(\"V1\", 11), LET('V2', 22))", code.toString());
|
|
112 |
assertEquals("IFF((\"V1\" = 11), LET('V2', 22))", code.toString());
|
|
113 | 113 |
} |
114 | 114 |
|
115 | 115 |
public void testIfThen2() { |
... | ... | |
118 | 118 |
Compiler compiler = createCompiler(); |
119 | 119 |
|
120 | 120 |
Code code = compiler.compileExpression(source); |
121 |
assertEquals("IFF(=(\"V1\", 11), LET('V2', 22))", code.toString());
|
|
121 |
assertEquals("IFF((\"V1\" = 11), LET('V2', 22))", code.toString());
|
|
122 | 122 |
} |
123 | 123 |
|
124 | 124 |
public void testIfThen3() { |
... | ... | |
127 | 127 |
Compiler compiler = createCompiler(); |
128 | 128 |
|
129 | 129 |
Code code = compiler.compileExpression(source); |
130 |
assertEquals("IFF(=(\"V1\", 11), LET('V2', 22))", code.toString());
|
|
130 |
assertEquals("IFF((\"V1\" = 11), LET('V2', 22))", code.toString());
|
|
131 | 131 |
} |
132 | 132 |
|
133 | 133 |
public void testIfThenElse() { |
... | ... | |
136 | 136 |
Compiler compiler = createCompiler(); |
137 | 137 |
|
138 | 138 |
Code code = compiler.compileExpression(source); |
139 |
assertEquals("IFF(=(\"V1\", 11), LET('V2', 11), LET('V2', 22))", code.toString());
|
|
139 |
assertEquals("IFF((\"V1\" = 11), LET('V2', 11), LET('V2', 22))", code.toString());
|
|
140 | 140 |
} |
141 | 141 |
|
142 | 142 |
public void testIfThenBlock() { |
... | ... | |
145 | 145 |
Compiler compiler = createCompiler(); |
146 | 146 |
|
147 | 147 |
Code code = compiler.compileExpression(source); |
148 |
assertEquals("IFF(=(\"V1\", 11), BLOCK(LET('V2', 22), LET('V1', 10)))", code.toString());
|
|
148 |
assertEquals("IFF((\"V1\" = 11), BLOCK(LET('V2', 22), LET('V1', 10)))", code.toString());
|
|
149 | 149 |
} |
150 | 150 |
|
151 | 151 |
public void testWhile() { |
... | ... | |
154 | 154 |
Compiler compiler = createCompiler(); |
155 | 155 |
|
156 | 156 |
Code code = compiler.compileExpression(source); |
157 |
assertEquals("WHILE(<(\"n\", 10), LET('n', +(\"n\", 1)))", code.toString());
|
|
157 |
assertEquals("WHILE((\"n\" < 10), LET('n', (\"n\" + 1)))", code.toString());
|
|
158 | 158 |
} |
159 | 159 |
|
160 | 160 |
public void testWhileBlock() { |
... | ... | |
163 | 163 |
Compiler compiler = createCompiler(); |
164 | 164 |
|
165 | 165 |
Code code = compiler.compileExpression(source); |
166 |
assertEquals("WHILE(<(\"n\", 10), BLOCK(LET('n', +(\"n\", 1)), print(\"n\")))", code.toString());
|
|
166 |
assertEquals("WHILE((\"n\" < 10), BLOCK(LET('n', (\"n\" + 1)), print(\"n\")))", code.toString());
|
|
167 | 167 |
} |
168 | 168 |
|
169 | 169 |
public void testCast() { |
... | ... | |
226 | 226 |
Compiler compiler = createCompiler(); |
227 | 227 |
|
228 | 228 |
Code code = compiler.compileExpression(source); |
229 |
assertEquals("CASE(LIKE(\"software\", '%gvSIG%'), 'gvSIG', 'Other')", code.toString());
|
|
229 |
assertEquals("CASE((\"software\" LIKE '%gvSIG%'), 'gvSIG', 'Other')", code.toString());
|
|
230 | 230 |
} |
231 | 231 |
|
232 | 232 |
public void testCase1() { |
... | ... | |
235 | 235 |
Compiler compiler = createCompiler(); |
236 | 236 |
|
237 | 237 |
Code code = compiler.compileExpression(source); |
238 |
assertEquals("CASE(LIKE(\"software\", '%gvSIG%'), 'gvSIG', 'Other')", code.toString());
|
|
238 |
assertEquals("CASE((\"software\" LIKE '%gvSIG%'), 'gvSIG', 'Other')", code.toString());
|
|
239 | 239 |
} |
240 | 240 |
|
241 | 241 |
public void testCase2() { |
... | ... | |
244 | 244 |
Compiler compiler = createCompiler(); |
245 | 245 |
|
246 | 246 |
Code code = compiler.compileExpression(source); |
247 |
assertEquals("CASE(AND(>=(\"Field_1\", 75), <=(\"Field_1\", 79)), AND(>=(\"Field_1\", 80), <=(\"Field_1\", 84)), 100, 110)", code.toString());
|
|
247 |
assertEquals("CASE(((\"Field_1\" >= 75) AND (\"Field_1\" <= 79)), ((\"Field_1\" >= 80) AND (\"Field_1\" <= 84)), 100, 110)", code.toString());
|
|
248 | 248 |
} |
249 | 249 |
|
250 | 250 |
public void testCase3() { |
... | ... | |
253 | 253 |
Compiler compiler = createCompiler(); |
254 | 254 |
|
255 | 255 |
Code code = compiler.compileExpression(source); |
256 |
assertEquals("CASE(AND(>=(\"Field_1\", 75), <=(\"Field_1\", 79)), AND(>=(\"Field_1\", 80), <=(\"Field_1\", 84)), 100, 110, 120)", code.toString());
|
|
256 |
assertEquals("CASE(((\"Field_1\" >= 75) AND (\"Field_1\" <= 79)), ((\"Field_1\" >= 80) AND (\"Field_1\" <= 84)), 100, 110, 120)", code.toString());
|
|
257 | 257 |
} |
258 | 258 |
|
259 | 259 |
public void testDef1() { |
... | ... | |
271 | 271 |
Compiler compiler = createCompiler(); |
272 | 272 |
|
273 | 273 |
Code code = compiler.compileExpression(source); |
274 |
assertEquals("CREATE_FUNCTION('test1', LIST('nombre'), print(+('Hola ', \"nombre\")))", code.toString());
|
|
274 |
assertEquals("CREATE_FUNCTION('test1', LIST('nombre'), print(('Hola ' + \"nombre\")))", code.toString());
|
|
275 | 275 |
} |
276 | 276 |
|
277 | 277 |
public void testDef3() { |
... | ... | |
280 | 280 |
Compiler compiler = createCompiler(); |
281 | 281 |
|
282 | 282 |
Code code = compiler.compileExpression(source); |
283 |
assertEquals("CREATE_FUNCTION('test1', LIST('nombre'), BLOCK(RETURN(||('Hola ', \"nombre\"))))", code.toString());
|
|
283 |
assertEquals("CREATE_FUNCTION('test1', LIST('nombre'), BLOCK(RETURN(('Hola ' || \"nombre\"))))", code.toString());
|
|
284 | 284 |
} |
285 | 285 |
|
286 | 286 |
public void testUseCase1() { |
... | ... | |
289 | 289 |
Compiler compiler = createCompiler(); |
290 | 290 |
|
291 | 291 |
Code code = compiler.compileExpression(source); |
292 |
assertEquals("BLOCK(LET('x', ''), FOREACH('n', list('hola', 'adios', 'fin'), LET('x', ||(||(\"x\", ' '), \"n\"))))", code.toString());
|
|
292 |
assertEquals("BLOCK(LET('x', ''), FOREACH('n', list('hola', 'adios', 'fin'), LET('x', ((\"x\" || ' ') || \"n\"))))", code.toString());
|
|
293 | 293 |
} |
294 | 294 |
|
295 | 295 |
public void testUseCase2() { |
... | ... | |
298 | 298 |
Compiler compiler = createCompiler(); |
299 | 299 |
|
300 | 300 |
Code code = compiler.compileExpression(source); |
301 |
assertEquals("BLOCK(LET('s', ''), LET('x', LIST('hola', 'adios', 'fin')), FOREACH('n', RANGE(3), LET('s', ||(||(\"s\", ' '), GETITEM(\"x\", \"n\")))))", code.toString());
|
|
301 |
assertEquals("BLOCK(LET('s', ''), LET('x', LIST('hola', 'adios', 'fin')), FOREACH('n', RANGE(3), LET('s', ((\"s\" || ' ') || GETITEM(\"x\", \"n\")))))", code.toString());
|
|
302 | 302 |
} |
303 | 303 |
|
304 | 304 |
|
trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.lib/org.gvsig.expressionevaluator.lib.impl/src/test/java/org/gvsig/expresionevaluator/impl/TestOptimizer.java | ||
---|---|---|
223 | 223 |
|
224 | 224 |
Compiler compiler = createCompiler(); |
225 | 225 |
Code code = compiler.compileExpression(source); |
226 |
assertEquals(operatorName + "(\"precio\", 23)", code.toString());
|
|
226 |
assertEquals( "(\"precio\" "+operatorName+" 23)", code.toString());
|
|
227 | 227 |
|
228 | 228 |
SymbolTable symbolTable = createSymbolTable(); |
229 | 229 |
Optimizer optimizer = createOptimizer(symbolTable); |
230 | 230 |
Code code2 = optimizer.optimize(code); |
231 |
assertEquals(operatorName + "(\"precio\", 23)", code2.toString());
|
|
231 |
assertEquals( "(\"precio\" "+operatorName+" 23)", code2.toString());
|
|
232 | 232 |
} |
233 | 233 |
|
234 | 234 |
public void testOperators() { |
... | ... | |
259 | 259 |
Compiler compiler = createCompiler(); |
260 | 260 |
|
261 | 261 |
Code code = compiler.compileExpression(source); |
262 |
assertEquals("+(+(+(\"precio\", *(10, 2)), 20), 30)", code.toString());
|
|
262 |
assertEquals("(((\"precio\" + (10 * 2)) + 20) + 30)", code.toString());
|
|
263 | 263 |
|
264 | 264 |
SymbolTable symbolTable = createSymbolTable(); |
265 | 265 |
Optimizer optimizer = createOptimizer(symbolTable); |
266 | 266 |
Code code2 = optimizer.optimize(code); |
267 |
assertEquals("+(+(+(\"precio\", 20), 20), 30)", code2.toString());
|
|
267 |
assertEquals("(((\"precio\" + 20) + 20) + 30)", code2.toString());
|
|
268 | 268 |
} |
269 | 269 |
|
270 | 270 |
public void testMul0() { |
... | ... | |
273 | 273 |
Compiler compiler = createCompiler(); |
274 | 274 |
|
275 | 275 |
Code code = compiler.compileExpression(source); |
276 |
assertEquals("+(+(+(\"precio\", *(10, 0)), 20), 30)", code.toString());
|
|
276 |
assertEquals("(((\"precio\" + (10 * 0)) + 20) + 30)", code.toString());
|
|
277 | 277 |
|
278 | 278 |
SymbolTable symbolTable = createSymbolTable(); |
279 | 279 |
Optimizer optimizer = createOptimizer(symbolTable); |
280 | 280 |
Code code2 = optimizer.optimize(code); |
281 |
assertEquals("+(+(\"precio\", 20), 30)", code2.toString());
|
|
281 |
assertEquals("((\"precio\" + 20) + 30)", code2.toString());
|
|
282 | 282 |
} |
283 | 283 |
|
284 | 284 |
public void testMul1() { |
... | ... | |
287 | 287 |
Compiler compiler = createCompiler(); |
288 | 288 |
|
289 | 289 |
Code code = compiler.compileExpression(source); |
290 |
assertEquals("+(+(+(\"precio\", *(10, 1)), 20), 30)", code.toString());
|
|
290 |
assertEquals("(((\"precio\" + (10 * 1)) + 20) + 30)", code.toString());
|
|
291 | 291 |
|
292 | 292 |
SymbolTable symbolTable = createSymbolTable(); |
293 | 293 |
Optimizer optimizer = createOptimizer(symbolTable); |
294 | 294 |
Code code2 = optimizer.optimize(code); |
295 |
assertEquals("+(+(+(\"precio\", 10), 20), 30)", code2.toString());
|
|
295 |
assertEquals("(((\"precio\" + 10) + 20) + 30)", code2.toString());
|
|
296 | 296 |
} |
297 | 297 |
|
298 | 298 |
public void testDiv1() { |
... | ... | |
301 | 301 |
Compiler compiler = createCompiler(); |
302 | 302 |
|
303 | 303 |
Code code = compiler.compileExpression(source); |
304 |
assertEquals("+(+(+(\"precio\", /(10, 1)), 20), 30)", code.toString());
|
|
304 |
assertEquals("(((\"precio\" + (10 / 1)) + 20) + 30)", code.toString());
|
|
305 | 305 |
|
306 | 306 |
SymbolTable symbolTable = createSymbolTable(); |
307 | 307 |
Optimizer optimizer = createOptimizer(symbolTable); |
308 | 308 |
Code code2 = optimizer.optimize(code); |
309 |
assertEquals("+(+(+(\"precio\", 10), 20), 30)", code2.toString());
|
|
309 |
assertEquals("(((\"precio\" + 10) + 20) + 30)", code2.toString());
|
|
310 | 310 |
} |
311 | 311 |
|
312 | 312 |
public void testDiv0() { |
... | ... | |
315 | 315 |
Compiler compiler = createCompiler(); |
316 | 316 |
|
317 | 317 |
Code code = compiler.compileExpression(source); |
318 |
assertEquals("+(+(+(\"precio\", /(0, 10)), 20), 30)", code.toString());
|
|
318 |
assertEquals("(((\"precio\" + (0 / 10)) + 20) + 30)", code.toString());
|
|
319 | 319 |
|
320 | 320 |
SymbolTable symbolTable = createSymbolTable(); |
321 | 321 |
Optimizer optimizer = createOptimizer(symbolTable); |
322 | 322 |
Code code2 = optimizer.optimize(code); |
323 |
assertEquals("+(+(\"precio\", 20), 30)", code2.toString());
|
|
323 |
assertEquals("((\"precio\" + 20) + 30)", code2.toString());
|
|
324 | 324 |
} |
325 | 325 |
|
326 | 326 |
public void testAddMulPar() { |
... | ... | |
329 | 329 |
Compiler compiler = createCompiler(); |
330 | 330 |
|
331 | 331 |
Code code = compiler.compileExpression(source); |
332 |
assertEquals("+(+(*(+(\"precio\", 10), 2), 20), 30)", code.toString());
|
|
332 |
assertEquals("((((\"precio\" + 10) * 2) + 20) + 30)", code.toString());
|
|
333 | 333 |
|
334 | 334 |
SymbolTable symbolTable = createSymbolTable(); |
335 | 335 |
Optimizer optimizer = createOptimizer(symbolTable); |
336 | 336 |
Code code2 = optimizer.optimize(code); |
337 |
assertEquals("+(+(*(+(\"precio\", 10), 2), 20), 30)", code2.toString());
|
|
337 |
assertEquals("((((\"precio\" + 10) * 2) + 20) + 30)", code2.toString());
|
|
338 | 338 |
} |
339 | 339 |
|
340 | 340 |
public void testAbs() { |
... | ... | |
343 | 343 |
Compiler compiler = createCompiler(); |
344 | 344 |
|
345 | 345 |
Code code = compiler.compileExpression(source); |
346 |
assertEquals("+(\"precio\", abs(10))", code.toString());
|
|
346 |
assertEquals("(\"precio\" + abs(10))", code.toString());
|
|
347 | 347 |
|
348 | 348 |
SymbolTable symbolTable = createSymbolTable(); |
349 | 349 |
Optimizer optimizer = createOptimizer(symbolTable); |
350 | 350 |
Code code2 = optimizer.optimize(code); |
351 |
assertEquals("+(\"precio\", 10)", code2.toString());
|
|
351 |
assertEquals("(\"precio\" + 10)", code2.toString());
|
|
352 | 352 |
} |
353 | 353 |
|
354 | 354 |
public void testAbs2() { |
... | ... | |
357 | 357 |
Compiler compiler = createCompiler(); |
358 | 358 |
|
359 | 359 |
Code code = compiler.compileExpression(source); |
360 |
assertEquals("+(\"precio\", abs(NEGATE(10)))", code.toString());
|
|
360 |
assertEquals("(\"precio\" + abs(-(10)))", code.toString());
|
|
361 | 361 |
|
362 | 362 |
SymbolTable symbolTable = createSymbolTable(); |
363 | 363 |
Optimizer optimizer = createOptimizer(symbolTable); |
364 | 364 |
Code code2 = optimizer.optimize(code); |
365 |
assertEquals("+(\"precio\", 10)", code2.toString());
|
|
365 |
assertEquals("(\"precio\" + 10)", code2.toString());
|
|
366 | 366 |
} |
367 | 367 |
|
368 | 368 |
public void testPI() { |
... | ... | |
371 | 371 |
Compiler compiler = createCompiler(); |
372 | 372 |
|
373 | 373 |
Code code = compiler.compileExpression(source); |
374 |
assertEquals("+(\"precio\", PI())", code.toString());
|
|
374 |
assertEquals("(\"precio\" + PI())", code.toString());
|
|
375 | 375 |
|
376 | 376 |
SymbolTable symbolTable = createSymbolTable(); |
377 | 377 |
Optimizer optimizer = createOptimizer(symbolTable); |
378 | 378 |
Code code2 = optimizer.optimize(code); |
379 |
assertEquals("+(\"precio\", 3.141592653589793)", code2.toString());
|
|
379 |
assertEquals("(\"precio\" + 3.141592653589793)", code2.toString());
|
|
380 | 380 |
} |
381 | 381 |
|
382 | 382 |
public void testCeil() { |
... | ... | |
385 | 385 |
Compiler compiler = createCompiler(); |
386 | 386 |
|
387 | 387 |
Code code = compiler.compileExpression(source); |
388 |
assertEquals("+(\"precio\", CEIL(PI()))", code.toString());
|
|
388 |
assertEquals("(\"precio\" + CEIL(PI()))", code.toString());
|
|
389 | 389 |
|
390 | 390 |
SymbolTable symbolTable = createSymbolTable(); |
391 | 391 |
Optimizer optimizer = createOptimizer(symbolTable); |
392 | 392 |
Code code2 = optimizer.optimize(code); |
393 |
assertEquals("+(\"precio\", 4.0)", code2.toString());
|
|
393 |
assertEquals("(\"precio\" + 4.0)", code2.toString());
|
|
394 | 394 |
} |
395 | 395 |
|
396 | 396 |
public void testConcat() { |
... | ... | |
452 | 452 |
public void testSpatialExpression1() throws Exception { |
453 | 453 |
IProjection proj = CRSFactory.getCRS("EPSG:4326"); |
454 | 454 |
ExpressionBuilder builder = new DefaultExpressionBuilder(); |
455 |
builder.getConfig().set(ExpressionBuilder.Config.geometry_type_support, ExpressionBuilder.GeometrySupportType.WKB);
|
|
455 |
builder.geometry_support_type(ExpressionBuilder.GeometrySupportType.WKB);
|
|
456 | 456 |
|
457 | 457 |
String source = builder.and( |
458 | 458 |
builder.custom(this.createExpr1()), |
... | ... | |
471 | 471 |
Code code = compiler.compileExpression(source); |
472 | 472 |
System.out.println(code.toString()); |
473 | 473 |
assertEquals( |
474 |
"AND(>(\"campo1\", 10), ST_Intersects(ST_GeomFromWKB(DECODE('000000000300000001000000050000000000000000000000000000000000000000000000004059000000000000405900000000000040590000000000004059000000000000000000000000000000000000000000000000000000000000', 'hex'), 4326), \"GEOMETRY\"))",
|
|
474 |
"((\"campo1\" > 10) AND ST_Intersects(ST_GeomFromWKB(DECODE('000000000300000001000000050000000000000000000000000000000000000000000000004059000000000000405900000000000040590000000000004059000000000000000000000000000000000000000000000000000000000000', 'hex'), 4326), \"GEOMETRY\"))",
|
|
475 | 475 |
code.toString() |
476 | 476 |
); |
477 | 477 |
|
... | ... | |
487 | 487 |
// System.out.println("Tiempo de optimizacion: " + (System.currentTimeMillis() - t1)); |
488 | 488 |
System.out.println(code2.toString()); |
489 | 489 |
assertEquals( |
490 |
"AND(>(\"campo1\", 10), ST_Intersects('POLYGON ((0 0, 0 100, 100 100, 100 0, 0 0))'::geometry, \"GEOMETRY\"))",
|
|
490 |
"((\"campo1\" > 10) AND ST_Intersects('POLYGON ((0 0, 0 100, 100 100, 100 0, 0 0))'::geometry, \"GEOMETRY\"))",
|
|
491 | 491 |
code2.toString() |
492 | 492 |
); |
493 | 493 |
|
trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.lib/org.gvsig.expressionevaluator.lib.impl/src/test/java/org/gvsig/expresionevaluator/impl/TestExpressionBuilder.java | ||
---|---|---|
1 | 1 |
package org.gvsig.expresionevaluator.impl; |
2 | 2 |
|
3 |
import java.util.ArrayList; |
|
4 |
import java.util.List; |
|
5 | 3 |
import junit.framework.TestCase; |
6 | 4 |
import org.apache.commons.lang3.ArrayUtils; |
7 | 5 |
import org.cresques.cts.IProjection; |
8 | 6 |
import org.gvsig.expressionevaluator.ExpressionBuilder; |
9 |
import org.gvsig.expressionevaluator.ExpressionBuilder.Config; |
|
10 | 7 |
import org.gvsig.expressionevaluator.ExpressionBuilder.GeometrySupportType; |
11 |
import org.gvsig.expressionevaluator.ExpressionBuilder.Parameter; |
|
12 |
import org.gvsig.expressionevaluator.ExpressionBuilder.Variable; |
|
13 | 8 |
import org.gvsig.expressionevaluator.impl.DefaultExpressionBuilder; |
14 | 9 |
import org.gvsig.fmap.crs.CRSFactory; |
15 | 10 |
import org.gvsig.fmap.geom.Geometry; |
... | ... | |
29 | 24 |
protected void setUp() throws Exception { |
30 | 25 |
super.setUp(); |
31 | 26 |
new DefaultLibrariesInitializer().fullInitialize(); |
32 |
// new ExpressionEvaluatorImplLibrary().initialize(); |
|
33 | 27 |
} |
34 | 28 |
|
35 | 29 |
@Override |
... | ... | |
40 | 34 |
// TODO add test methods here. The name must begin with 'test'. For example: |
41 | 35 |
// public void testHello() {} |
42 | 36 |
|
43 |
List<String> getVariableNames(ExpressionBuilder builder) { |
|
44 |
List<String> vars = new ArrayList<>(); |
|
45 |
for (Variable var : builder.getVariables()) { |
|
46 |
vars.add(var.getName()); |
|
47 |
} |
|
48 |
return vars; |
|
49 |
} |
|
50 |
|
|
51 |
List<String> getParameterNames(ExpressionBuilder builder) { |
|
52 |
List<String> params = new ArrayList<>(); |
|
53 |
for (Parameter param : builder.getParameters()) { |
|
54 |
String s; |
|
55 |
switch(param.getType()) { |
|
56 |
case Constant: |
|
57 |
Object value = param.getValue(); |
|
58 |
if( value==null ) { |
|
59 |
s = "null"; |
|
60 |
} else if( value instanceof String ) { |
|
61 |
s = "'" + (String)value + "'"; |
|
62 |
} else { |
|
63 |
s = value.toString(); |
|
64 |
} |
|
65 |
break; |
|
66 |
case Geometry: |
|
67 |
case Variable: |
|
68 |
default: |
|
69 |
s = "\"" + param.getName() + "\""; |
|
70 |
} |
|
71 |
params.add(s); |
|
72 |
} |
|
73 |
return params; |
|
74 |
} |
|
75 |
|
|
76 | 37 |
public void test2() { |
77 | 38 |
ExpressionBuilder builder = new DefaultExpressionBuilder(); |
78 | 39 |
|
79 | 40 |
builder.and( |
80 | 41 |
builder.eq( |
81 |
builder.lcase(builder.variable("colum_name_c")),
|
|
42 |
builder.lower(builder.variable("colum_name_c")),
|
|
82 | 43 |
builder.parameter("colum_name_p") |
83 | 44 |
) |
84 | 45 |
); |
... | ... | |
86 | 47 |
builder.group( |
87 | 48 |
builder.or( |
88 | 49 |
builder.like( |
89 |
builder.lcase( builder.variable("uno")),
|
|
50 |
builder.lower( builder.variable("uno")),
|
|
90 | 51 |
builder.constant("%10") |
91 | 52 |
), |
92 | 53 |
builder.lt( |
... | ... | |
114 | 75 |
) |
115 | 76 |
); |
116 | 77 |
assertEquals( |
117 |
"( (LCASE(\"colum_name_c\")) = (?) ) AND ( ( (LCASE(\"uno\")) LIKE ('%10') ) OR ( (\"dos\") < (-3.5) ) ) AND ST_Intersects((\"geom1\"), (ST_Envelope(ST_GeomFromWKB((?), (?))))) AND ( (\"tres\") > (123456789) )",
|
|
78 |
"( (LOWER(\"colum_name_c\")) = (?) ) AND ( ( (LOWER(\"uno\")) LIKE ('%10') ) OR ( (\"dos\") < (-3.5) ) ) AND ST_Intersects((\"geom1\"), (ST_Envelope(ST_GeomFromWKB((?), (?))))) AND ( (\"tres\") > (123456789) )",
|
|
118 | 79 |
builder.toString() |
119 | 80 |
); |
120 | 81 |
assertEquals( |
121 | 82 |
"[colum_name_c, dos, geom1, tres, uno]", |
122 |
ArrayUtils.toString(getVariableNames(builder))
|
|
83 |
ArrayUtils.toString(builder.variables_names())
|
|
123 | 84 |
); |
124 | 85 |
assertEquals( |
125 | 86 |
"[\"colum_name_p\", \"geom2\", 4326]", |
126 |
ArrayUtils.toString(getParameterNames(builder))
|
|
87 |
ArrayUtils.toString(builder.parameters_names())
|
|
127 | 88 |
); |
128 | 89 |
} |
129 | 90 |
|
... | ... | |
140 | 101 |
builder.variable("the_geom") |
141 | 102 |
) |
142 | 103 |
); |
143 |
builder.getConfig().set(Config.geometry_type_support, GeometrySupportType.WKT);
|
|
104 |
builder.geometry_support_type(GeometrySupportType.WKT);
|
|
144 | 105 |
System.out.println(builder.toString()); |
145 | 106 |
assertEquals( |
146 |
"ST_Intersects((ST_GeomFromText('POINT (10 20)', (4326))), (\"the_geom\"))",
|
|
107 |
"ST_Intersects((ST_GeomFromText(('POINT (10 20)'), (4326))), (\"the_geom\"))",
|
|
147 | 108 |
builder.toString() |
148 | 109 |
); |
149 |
builder.getConfig().set(Config.geometry_type_support, GeometrySupportType.WKB);
|
|
110 |
builder.geometry_support_type(GeometrySupportType.WKB);
|
|
150 | 111 |
System.out.println(builder.toString()); |
151 | 112 |
assertEquals( |
152 | 113 |
"ST_Intersects((ST_GeomFromWKB((DECODE('000000000140240000000000004034000000000000','hex')), (4326))), (\"the_geom\"))", |
... | ... | |
154 | 115 |
); |
155 | 116 |
assertEquals( |
156 | 117 |
"[the_geom]", |
157 |
ArrayUtils.toString(getVariableNames(builder))
|
|
118 |
ArrayUtils.toString(builder.variables_names())
|
|
158 | 119 |
); |
159 | 120 |
assertEquals( |
160 | 121 |
"[]", |
161 |
ArrayUtils.toString(getParameterNames(builder))
|
|
122 |
ArrayUtils.toString(builder.parameters_names())
|
|
162 | 123 |
); |
163 | 124 |
} |
164 | 125 |
|
126 |
public void testParameter() throws CreateGeometryException { |
|
127 |
ExpressionBuilder builder = new DefaultExpressionBuilder(); |
|
128 |
|
|
129 |
GeometryManager geometryManager = GeometryLocator.getGeometryManager(); |
|
130 |
IProjection proj = CRSFactory.getCRS("EPSG:4326"); |
|
131 |
|
|
132 |
Point point = geometryManager.createPoint(10, 20, Geometry.SUBTYPES.GEOM2D); |
|
133 |
builder.set( |
|
134 |
builder.ST_Intersects( |
|
135 |
builder.geometry(point,proj), |
|
136 |
builder.parameter("the_geom") |
|
137 |
) |
|
138 |
); |
|
139 |
builder.geometry_support_type(GeometrySupportType.WKT); |
|
140 |
System.out.println(builder.toString()); |
|
141 |
assertEquals( |
|
142 |
"ST_Intersects((ST_GeomFromText(('POINT (10 20)'), (4326))), (?))", |
|
143 |
builder.toString() |
|
144 |
); |
|
145 |
builder.geometry_support_type(GeometrySupportType.WKB); |
|
146 |
System.out.println(builder.toString()); |
|
147 |
assertEquals( |
|
148 |
"ST_Intersects((ST_GeomFromWKB((DECODE('000000000140240000000000004034000000000000','hex')), (4326))), (?))", |
|
149 |
builder.toString() |
|
150 |
); |
|
151 |
assertEquals( |
|
152 |
"[]", |
|
153 |
ArrayUtils.toString(builder.variables_names()) |
|
154 |
); |
|
155 |
assertEquals( |
|
156 |
"[\"the_geom\"]", |
|
157 |
ArrayUtils.toString(builder.parameters_names()) |
|
158 |
); |
|
159 |
} |
|
160 |
|
|
161 |
public void testParameterGeomWhitoutSRS() throws CreateGeometryException { |
|
162 |
ExpressionBuilder builder = new DefaultExpressionBuilder(); |
|
163 |
|
|
164 |
GeometryManager geometryManager = GeometryLocator.getGeometryManager(); |
|
165 |
IProjection proj = CRSFactory.getCRS("EPSG:4326"); |
|
166 |
|
|
167 |
Point point = geometryManager.createPoint(10, 20, Geometry.SUBTYPES.GEOM2D); |
|
168 |
builder.set( |
|
169 |
builder.ST_Intersects( |
|
170 |
builder.geometry(point,proj), |
|
171 |
builder.parameter("the_geom").as_geometry_variable() |
|
172 |
) |
|
173 |
); |
|
174 |
try { |
|
175 |
builder.toString(); |
|
176 |
fail("Geometry parameter without SRS not detected."); |
|
177 |
} catch(IllegalArgumentException ex) { |
|
178 |
// Do nothing, it's ok that fail if not SRS is specified. |
|
179 |
} |
|
180 |
} |
|
181 |
|
|
182 |
public void testPatameterGeomWithSRS1() throws CreateGeometryException { |
|
183 |
ExpressionBuilder builder = new DefaultExpressionBuilder(); |
|
184 |
|
|
185 |
GeometryManager geometryManager = GeometryLocator.getGeometryManager(); |
|
186 |
IProjection proj = CRSFactory.getCRS("EPSG:4326"); |
|
187 |
|
|
188 |
Point point = geometryManager.createPoint(10, 20, Geometry.SUBTYPES.GEOM2D); |
|
189 |
builder.set( |
|
190 |
builder.ST_Intersects( |
|
191 |
builder.geometry(point,proj), |
|
192 |
builder.parameter("the_geom").srs(proj) |
|
193 |
) |
|
194 |
); |
|
195 |
builder.geometry_support_type(GeometrySupportType.WKT); |
|
196 |
System.out.println(builder.toString()); |
|
197 |
assertEquals( |
|
198 |
"ST_Intersects((ST_GeomFromText(('POINT (10 20)'), (4326))), (ST_GeomFromText((?), (4326))))", |
|
199 |
builder.toString() |
|
200 |
); |
|
201 |
builder.geometry_support_type(GeometrySupportType.WKB); |
|
202 |
System.out.println(builder.toString()); |
|
203 |
assertEquals( |
|
204 |
"ST_Intersects((ST_GeomFromWKB((DECODE('000000000140240000000000004034000000000000','hex')), (4326))), (ST_GeomFromWKB((?), (4326))))", |
|
205 |
builder.toString() |
|
206 |
); |
|
207 |
assertEquals( |
|
208 |
"[]", |
|
209 |
ArrayUtils.toString(builder.variables_names()) |
|
210 |
); |
|
211 |
assertEquals( |
|
212 |
"[\"the_geom\"]", |
|
213 |
ArrayUtils.toString(builder.parameters_names()) |
|
214 |
); |
|
215 |
} |
|
216 |
|
|
217 |
public void testParameterGeomWithSRS2() throws CreateGeometryException { |
|
218 |
ExpressionBuilder builder = new DefaultExpressionBuilder(); |
|
219 |
|
|
220 |
GeometryManager geometryManager = GeometryLocator.getGeometryManager(); |
|
221 |
IProjection proj = CRSFactory.getCRS("EPSG:4326"); |
|
222 |
|
|
223 |
Point point = geometryManager.createPoint(10, 20, Geometry.SUBTYPES.GEOM2D); |
|
224 |
builder.set( |
|
225 |
builder.ST_Intersects( |
|
226 |
builder.geometry(point,proj), |
|
227 |
builder.parameter("the_geom").srs(builder.constant(4326)) |
|
228 |
) |
|
229 |
); |
|
230 |
builder.geometry_support_type(GeometrySupportType.WKT); |
|
231 |
System.out.println(builder.toString()); |
|
232 |
assertEquals( |
|
233 |
"ST_Intersects((ST_GeomFromText(('POINT (10 20)'), (4326))), (ST_GeomFromText((?), (4326))))", |
|
234 |
builder.toString() |
|
235 |
); |
|
236 |
builder.geometry_support_type(GeometrySupportType.WKB); |
|
237 |
System.out.println(builder.toString()); |
|
238 |
assertEquals( |
|
239 |
"ST_Intersects((ST_GeomFromWKB((DECODE('000000000140240000000000004034000000000000','hex')), (4326))), (ST_GeomFromWKB((?), (4326))))", |
|
240 |
builder.toString() |
|
241 |
); |
|
242 |
assertEquals( |
|
243 |
"[]", |
|
244 |
ArrayUtils.toString(builder.variables_names()) |
|
245 |
); |
|
246 |
assertEquals( |
|
247 |
"[\"the_geom\"]", |
|
248 |
ArrayUtils.toString(builder.parameters_names()) |
|
249 |
); |
|
250 |
} |
|
251 |
|
|
252 |
public void testParameterGeomWithParameterSRS() throws CreateGeometryException { |
|
253 |
ExpressionBuilder builder = new DefaultExpressionBuilder(); |
|
254 |
|
|
255 |
GeometryManager geometryManager = GeometryLocator.getGeometryManager(); |
|
256 |
IProjection proj = CRSFactory.getCRS("EPSG:4326"); |
|
257 |
|
|
258 |
Point point = geometryManager.createPoint(10, 20, Geometry.SUBTYPES.GEOM2D); |
|
259 |
builder.set( |
|
260 |
builder.ST_Intersects( |
|
261 |
builder.geometry(point,proj), |
|
262 |
builder.parameter("the_geom").srs( |
|
263 |
builder.parameter().value(proj) |
|
264 |
) |
|
265 |
) |
|
266 |
); |
|
267 |
builder.geometry_support_type(GeometrySupportType.WKT); |
|
268 |
System.out.println(builder.toString()); |
|
269 |
assertEquals( |
|
270 |
"ST_Intersects((ST_GeomFromText(('POINT (10 20)'), (4326))), (ST_GeomFromText((?), (?))))", |
|
271 |
builder.toString() |
|
272 |
); |
|
273 |
builder.geometry_support_type(GeometrySupportType.WKB); |
|
274 |
System.out.println(builder.toString()); |
|
275 |
assertEquals( |
|
276 |
"ST_Intersects((ST_GeomFromWKB((DECODE('000000000140240000000000004034000000000000','hex')), (4326))), (ST_GeomFromWKB((?), (?))))", |
|
277 |
builder.toString() |
|
278 |
); |
|
279 |
assertEquals( |
|
280 |
"[]", |
|
281 |
ArrayUtils.toString(builder.variables_names()) |
|
282 |
); |
|
283 |
assertEquals( |
|
284 |
"[\"the_geom\", 4326]", |
|
285 |
ArrayUtils.toString(builder.parameters_names()) |
|
286 |
); |
|
287 |
} |
|
288 |
|
|
289 |
public void testParameterGeomConstant() throws CreateGeometryException { |
|
290 |
ExpressionBuilder builder = new DefaultExpressionBuilder(); |
|
291 |
|
|
292 |
GeometryManager geometryManager = GeometryLocator.getGeometryManager(); |
|
293 |
IProjection proj = CRSFactory.getCRS("EPSG:4326"); |
|
294 |
|
|
295 |
Point point = geometryManager.createPoint(10, 20, Geometry.SUBTYPES.GEOM2D); |
|
296 |
Point point2 = geometryManager.createPoint(10, 20, Geometry.SUBTYPES.GEOM2D); |
|
297 |
point2.setProjection(proj); |
|
298 |
builder.set( |
|
299 |
builder.ST_Intersects( |
|
300 |
builder.geometry(point,proj), |
|
301 |
builder.parameter().value(point2) |
|
302 |
) |
|
303 |
); |
|
304 |
builder.geometry_support_type(GeometrySupportType.WKT); |
|
305 |
System.out.println(builder.toString()); |
|
306 |
assertEquals( |
|
307 |
"ST_Intersects((ST_GeomFromText(('POINT (10 20)'), (4326))), (ST_GeomFromText((?), (?))))", |
|
308 |
builder.toString() |
|
309 |
); |
|
310 |
builder.geometry_support_type(GeometrySupportType.WKB); |
|
311 |
System.out.println(builder.toString()); |
|
312 |
assertEquals( |
|
313 |
"ST_Intersects((ST_GeomFromWKB((DECODE('000000000140240000000000004034000000000000','hex')), (4326))), (ST_GeomFromWKB((?), (?))))", |
|
314 |
builder.toString() |
|
315 |
); |
|
316 |
assertEquals( |
|
317 |
"[]", |
|
318 |
ArrayUtils.toString(builder.variables_names()) |
|
319 |
); |
|
320 |
assertEquals( |
|
321 |
"[0x000000000140240000000000004034000000000000, 4326]", |
|
322 |
ArrayUtils.toString(builder.parameters_names()) |
|
323 |
); |
|
324 |
} |
|
325 |
|
|
165 | 326 |
public void test4() throws CreateGeometryException { |
166 | 327 |
ExpressionBuilder builder = new DefaultExpressionBuilder(); |
167 | 328 |
|
... | ... | |
186 | 347 |
); |
187 | 348 |
assertEquals( |
188 | 349 |
"[geom1]", |
189 |
ArrayUtils.toString(getVariableNames(builder))
|
|
350 |
ArrayUtils.toString(builder.variables_names())
|
|
190 | 351 |
); |
191 | 352 |
assertEquals( |
192 | 353 |
"[\"geom2\", 4326]", |
193 |
ArrayUtils.toString(getParameterNames(builder))
|
|
354 |
ArrayUtils.toString(builder.parameters_names())
|
|
194 | 355 |
); |
195 | 356 |
} |
196 | 357 |
|
... | ... | |
213 | 374 |
); |
214 | 375 |
assertEquals( |
215 | 376 |
"[geom]", |
216 |
ArrayUtils.toString(getVariableNames(builder))
|
|
377 |
ArrayUtils.toString(builder.variables_names())
|
|
217 | 378 |
); |
218 | 379 |
assertEquals( |
219 | 380 |
"[]", |
220 |
ArrayUtils.toString(getParameterNames(builder))
|
|
381 |
ArrayUtils.toString(builder.parameters_names())
|
|
221 | 382 |
); |
222 | 383 |
} |
223 | 384 |
} |
trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.lib/org.gvsig.expressionevaluator.lib.impl/src/test/java/org/gvsig/expresionevaluator/impl/TestCodeToValue.java | ||
---|---|---|
1 |
package org.gvsig.expresionevaluator.impl; |
|
2 |
|
|
3 |
import static junit.framework.Assert.assertEquals; |
|
4 |
import junit.framework.TestCase; |
|
5 |
import org.cresques.cts.IProjection; |
|
6 |
import org.gvsig.expressionevaluator.Code; |
|
7 |
import org.gvsig.expressionevaluator.ExpressionBuilder; |
|
8 |
import org.gvsig.expressionevaluator.ExpressionEvaluatorLocator; |
|
9 |
import org.gvsig.expressionevaluator.ExpressionEvaluatorManager; |
|
10 |
import org.gvsig.expressionevaluator.ExpressionUtils; |
|
11 |
import org.gvsig.expressionevaluator.LexicalAnalyzer; |
|
12 |
import org.gvsig.fmap.crs.CRSFactory; |
|
13 |
import org.gvsig.fmap.geom.GeometryUtils; |
|
14 |
import org.gvsig.fmap.geom.exception.CreateGeometryException; |
|
15 |
import org.gvsig.fmap.geom.primitive.Point; |
|
16 |
import org.gvsig.tools.library.impl.DefaultLibrariesInitializer; |
|
17 |
|
|
18 |
public class TestCodeToValue extends TestCase { |
|
19 |
|
|
20 |
public TestCodeToValue(String testName) { |
|
21 |
super(testName); |
|
22 |
} |
|
23 |
|
|
24 |
@Override |
|
25 |
protected void setUp() throws Exception { |
|
26 |
super.setUp(); |
|
27 |
new DefaultLibrariesInitializer().fullInitialize(); |
|
28 |
} |
|
29 |
|
|
30 |
@Override |
|
31 |
protected void tearDown() throws Exception { |
|
32 |
super.tearDown(); |
|
33 |
} |
|
34 |
|
|
35 |
// TODO add test methods here. The name must begin with 'test'. For example: |
|
36 |
// public void testHello() {} |
|
37 |
|
|
38 |
protected LexicalAnalyzer createLexicalAnalyzer() { |
|
39 |
ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager(); |
|
40 |
LexicalAnalyzer lexer = manager.createLexicalAnalyzer(); |
|
41 |
return lexer; |
|
42 |
} |
|
43 |
|
|
44 |
protected org.gvsig.expressionevaluator.Compiler createCompiler() { |
|
45 |
ExpressionEvaluatorManager manager = ExpressionEvaluatorLocator.getManager(); |
|
46 |
org.gvsig.expressionevaluator.Compiler compiler = manager.createCompiler(); |
|
47 |
compiler.setLexicalAnalyzer(createLexicalAnalyzer()); |
|
48 |
return compiler; |
|
49 |
} |
|
50 |
|
|
51 |
public Code compileExpression(String source) { |
|
52 |
org.gvsig.expressionevaluator.Compiler compiler = createCompiler(); |
|
53 |
Code code = compiler.compileExpression(source); |
|
54 |
return code; |
|
55 |
} |
|
56 |
|
|
57 |
public void testIdentifier1() { |
|
58 |
String source = "precio"; |
|
59 |
|
|
60 |
Code code = compileExpression(source); |
|
61 |
assertEquals("\"precio\"", code.toValue().toString()); |
|
62 |
} |
|
63 |
|
|
64 |
public void testIdentifier2() { |
|
65 |
org.gvsig.expressionevaluator.Compiler compiler = createCompiler(); |
|
66 |
compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(true); |
|
67 |
|
|
68 |
String source = "[precio]"; |
|
69 |
|
|
70 |
Code code = compiler.compileExpression(source); |
|
71 |
assertEquals("\"precio\"", code.toValue().toString()); |
|
72 |
} |
|
73 |
|
|
74 |
public void testIdentifier3() { |
|
75 |
String source = "\"precio\""; |
|
76 |
|
|
77 |
Code code = compileExpression(source); |
|
78 |
assertEquals("\"precio\"", code.toValue().toString()); |
|
79 |
} |
|
80 |
|
|
81 |
|
|
82 |
public void testTrue() { |
|
83 |
String source = "true"; |
|
84 |
|
|
85 |
Code code = compileExpression(source); |
|
86 |
assertEquals("TRUE", code.toValue().toString()); |
|
87 |
} |
|
88 |
|
|
89 |
public void testFalse() { |
|
90 |
String source = "false"; |
|
91 |
|
|
92 |
Code code = compileExpression(source); |
|
93 |
assertEquals("FALSE", code.toValue().toString()); |
|
94 |
} |
|
95 |
|
|
96 |
public void testNull() { |
|
97 |
String source = "null"; |
|
98 |
|
|
99 |
Code code = compileExpression(source); |
|
100 |
assertEquals("NULL", code.toValue().toString()); |
|
101 |
} |
|
102 |
|
|
103 |
public void testNotTrue() { |
|
104 |
String source = "not true"; |
|
105 |
|
|
106 |
Code code = compileExpression(source); |
|
107 |
assertEquals("NOT(TRUE)", code.toValue().toString()); |
|
108 |
} |
|
109 |
|
|
110 |
public void testInteger() { |
|
111 |
String source = "23"; |
|
112 |
|
|
113 |
Code code = compileExpression(source); |
|
114 |
assertEquals("23", code.toValue().toString()); |
|
115 |
} |
|
116 |
|
|
117 |
public void operator(String operatorName) { |
|
118 |
String source = "precio " + operatorName + " 23"; |
|
119 |
|
|
120 |
Code code = compileExpression(source); |
|
121 |
assertEquals("(\"precio\" "+ operatorName + " 23)", code.toValue().toString()); |
|
122 |
} |
|
123 |
|
|
124 |
public void testOperators() { |
|
125 |
|
|
126 |
operator("="); |
|
127 |
operator("<>"); |
|
128 |
operator(">"); |
|
129 |
operator(">="); |
|
130 |
operator("<"); |
|
131 |
operator("<="); |
|
132 |
operator("LIKE"); |
|
133 |
operator("ILIKE"); |
|
134 |
operator("||"); |
|
135 |
operator("+"); |
|
136 |
operator("-"); |
|
137 |
operator("*"); |
|
138 |
operator("OR"); |
|
139 |
operator("AND"); |
|
140 |
operator("%"); |
|
141 |
operator("IS"); |
|
142 |
|
|
143 |
operator("~"); |
|
144 |
} |
|
145 |
|
|
146 |
// public void testILike() { |
|
147 |
// String source = "precio ILike 23"; |
|
148 |
// |
|
149 |
// Code code = compileExpression(source); |
|
150 |
// assertEquals("LOWER(\"precio\") LIKE LOWER(23)", code.toValue().toString()); |
|
151 |
// } |
|
152 |
|
|
153 |
public void testAddMul() { |
|
154 |
String source = "precio + 10 * 2 + 20 + 30"; |
|
155 |
|
|
156 |
Code code = compileExpression(source); |
|
157 |
assertEquals("(((\"precio\" + (10 * 2)) + 20) + 30)", code.toValue().toString()); |
|
158 |
} |
|
159 |
|
|
160 |
public void testAddMulPar() { |
|
161 |
String source = "(precio + 10) * 2 + 20 + 30"; |
|
162 |
|
|
163 |
Code code = compileExpression(source); |
|
164 |
assertEquals("((((\"precio\" + 10) * 2) + 20) + 30)", code.toValue().toString()); |
|
165 |
} |
|
166 |
|
|
167 |
public void testAbs() { |
|
168 |
String source = "precio + abs(10)"; |
|
169 |
|
|
170 |
Code code = compileExpression(source); |
|
171 |
assertEquals("(\"precio\" + abs(10))", code.toValue().toString()); |
|
172 |
} |
|
173 |
|
|
174 |
public void testAbs2() { |
|
175 |
String source = "precio + abs(-10)"; |
|
176 |
|
|
177 |
Code code = compileExpression(source); |
|
178 |
assertEquals("(\"precio\" + abs(-(10)))", code.toValue().toString()); |
|
179 |
} |
|
180 |
|
|
181 |
public void testPI() { |
|
182 |
String source = "precio + PI()"; |
|
183 |
|
|
184 |
Code code = compileExpression(source); |
|
185 |
assertEquals("(\"precio\" + PI())", code.toValue().toString()); |
|
186 |
} |
|
187 |
|
|
188 |
public void testCeil() { |
|
189 |
String source = "precio + CEIL(PI())"; |
|
190 |
|
|
191 |
Code code = compileExpression(source); |
|
192 |
assertEquals("(\"precio\" + CEIL(PI()))", code.toValue().toString()); |
|
193 |
} |
|
194 |
|
|
195 |
public void testGetitem1() { |
|
196 |
String source = "LIST('uno','dos','tres')[1]" ; |
|
197 |
|
|
198 |
Code code = compileExpression(source); |
|
199 |
assertEquals("GETITEM(LIST('uno', 'dos', 'tres'), 1)", code.toValue().toString()); |
|
200 |
} |
|
201 |
|
|
202 |
public void testConcat() { |
|
203 |
String source = "CONCAT(precio,' euros')"; |
|
204 |
|
|
205 |
Code code = compileExpression(source); |
|
206 |
assertEquals("CONCAT(\"precio\", ' euros')", code.toValue().toString()); |
|
207 |
} |
|
208 |
|
|
209 |
public void test1() { |
|
210 |
String source = "NOMBRE03 = 'Torre d''En Besora (la)'"; |
|
211 |
|
|
212 |
Code code = compileExpression(source); |
|
213 |
assertEquals("(\"NOMBRE03\" = 'Torre d''En Besora (la)')", code.toValue().toString()); |
|
214 |
} |
|
215 |
|
|
216 |
public void test2() { |
|
217 |
org.gvsig.expressionevaluator.Compiler compiler = createCompiler(); |
|
218 |
compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(true); |
|
219 |
|
|
220 |
String source = "[1990] = 0.168873933773767"; |
|
221 |
|
|
222 |
Code code = compiler.compileExpression(source); |
|
223 |
assertEquals("(\"1990\" = 0.168873933773767)", code.toValue().toString()); |
|
224 |
} |
|
225 |
|
|
226 |
public void test2fields() { |
|
227 |
org.gvsig.expressionevaluator.Compiler compiler = createCompiler(); |
|
228 |
compiler.getLexicalAnalyzer().setUseBracketsForIdentifiers(true); |
|
229 |
|
|
230 |
String source = "[1990] = [precio]"; |
|
231 |
|
|
232 |
Code code = compiler.compileExpression(source); |
|
233 |
assertEquals("(\"1990\" = \"precio\")", code.toValue().toString()); |
|
234 |
} |
|
235 |
|
|
236 |
|
|
237 |
public void testInvokeFunction1() { |
|
238 |
String source = "ST_Area(GEOMETRY)"; |
|
239 |
|
|
240 |
Code code = compileExpression(source); |
|
241 |
assertEquals("ST_Area(\"GEOMETRY\")", code.toValue().toString()); |
|
242 |
} |
|
243 |
|
|
244 |
public void test3() throws CreateGeometryException { |
|
245 |
ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder(); |
|
246 |
|
|
247 |
IProjection proj = CRSFactory.getCRS("EPSG:4326"); |
|
248 |
Point point = GeometryUtils.createPoint(10, 20); |
|
249 |
|
|
250 |
builder.set( |
|
251 |
builder.ST_Intersects( |
|
252 |
builder.geometry(point,proj), |
|
253 |
builder.variable("the_geom") |
|
254 |
) |
|
255 |
); |
|
256 |
Code code = compileExpression(builder.toString()); |
|
257 |
assertEquals( |
|
258 |
"ST_Intersects(ST_GeomFromWKB(DECODE('000000000140240000000000004034000000000000', 'hex'), 4326), \"the_geom\")", |
|
259 |
code.toValue().toString() |
|
260 |
); |
|
261 |
} |
|
262 |
|
|
263 |
public void test4() throws CreateGeometryException { |
|
264 |
ExpressionBuilder builder = ExpressionUtils.createExpressionBuilder(); |
|
265 |
|
|
266 |
IProjection proj = CRSFactory.getCRS("EPSG:4326"); |
|
267 |
Point point = GeometryUtils.createPoint(10, 20); |
|
268 |
|
|
269 |
builder.set( |
|
270 |
builder.function("ST_Intersects2", |
|
271 |
builder.geometry(point,proj), |
|
272 |
builder.variable("the_geom") |
|
273 |
) |
|
274 |
); |
|
275 |
Code code = compileExpression(builder.toString()); |
|
276 |
assertEquals( |
|
277 |
"ST_Intersects2(ST_GeomFromWKB(DECODE('000000000140240000000000004034000000000000', 'hex'), 4326), \"the_geom\")", |
|
278 |
code.toValue().toString() |
|
279 |
); |
|
280 |
} |
|
281 |
|
|
282 |
} |
trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.lib/org.gvsig.expressionevaluator.lib.impl/src/test/java/org/gvsig/expresionevaluator/impl/TestCompiler.java | ||
---|---|---|
117 | 117 |
|
118 | 118 |
Compiler compiler = createCompiler(); |
119 | 119 |
Code code = compiler.compileExpression(source); |
120 |
assertEquals(operatorName+"(\"precio\", 23)", code.toString());
|
|
120 |
assertEquals("(\"precio\" "+ operatorName + " 23)", code.toString());
|
|
121 | 121 |
} |
122 | 122 |
|
123 | 123 |
public void testOperators() { |
... | ... | |
148 | 148 |
Compiler compiler = createCompiler(); |
149 | 149 |
|
150 | 150 |
Code code = compiler.compileExpression(source); |
151 |
assertEquals("+(+(+(\"precio\", *(10, 2)), 20), 30)", code.toString());
|
|
151 |
assertEquals("(((\"precio\" + (10 * 2)) + 20) + 30)", code.toString());
|
|
152 | 152 |
} |
153 | 153 |
|
154 | 154 |
public void testAddMulPar() { |
... | ... | |
157 | 157 |
Compiler compiler = createCompiler(); |
158 | 158 |
|
159 | 159 |
Code code = compiler.compileExpression(source); |
160 |
assertEquals("+(+(*(+(\"precio\", 10), 2), 20), 30)", code.toString());
|
|
160 |
assertEquals("((((\"precio\" + 10) * 2) + 20) + 30)", code.toString());
|
|
161 | 161 |
} |
162 | 162 |
|
163 | 163 |
public void testAbs() { |
... | ... | |
166 | 166 |
Compiler compiler = createCompiler(); |
167 | 167 |
|
168 | 168 |
Code code = compiler.compileExpression(source); |
169 |
assertEquals("+(\"precio\", abs(10))", code.toString());
|
|
169 |
assertEquals("(\"precio\" + abs(10))", code.toString());
|
|
170 | 170 |
} |
171 | 171 |
|
172 | 172 |
public void testAbs2() { |
... | ... | |
175 | 175 |
Compiler compiler = createCompiler(); |
176 | 176 |
|
177 | 177 |
Code code = compiler.compileExpression(source); |
178 |
assertEquals("+(\"precio\", abs(NEGATE(10)))", code.toString());
|
|
178 |
assertEquals("(\"precio\" + abs(-(10)))", code.toString());
|
|
179 | 179 |
} |
180 | 180 |
|
181 | 181 |
public void testPI() { |
... | ... | |
184 | 184 |
Compiler compiler = createCompiler(); |
185 | 185 |
|
186 | 186 |
Code code = compiler.compileExpression(source); |
187 |
assertEquals("+(\"precio\", PI())", code.toString());
|
|
187 |
assertEquals("(\"precio\" + PI())", code.toString());
|
|
188 | 188 |
} |
189 | 189 |
|
190 | 190 |
public void testCeil() { |
... | ... | |
193 | 193 |
Compiler compiler = createCompiler(); |
194 | 194 |
|
195 | 195 |
Code code = compiler.compileExpression(source); |
196 |
assertEquals("+(\"precio\", CEIL(PI()))", code.toString());
|
|
196 |
assertEquals("(\"precio\" + CEIL(PI()))", code.toString());
|
|
197 | 197 |
} |
198 | 198 |
|
199 | 199 |
public void testGetitem1() { |
... | ... | |
220 | 220 |
Compiler compiler = createCompiler(); |
221 | 221 |
|
222 | 222 |
Code code = compiler.compileExpression(source); |
223 |
assertEquals("=(\"NOMBRE03\", 'Torre d'En Besora (la)')", code.toString());
|
|
223 |
assertEquals("(\"NOMBRE03\" = 'Torre d''En Besora (la)')", code.toString());
|
|
224 | 224 |
} |
225 | 225 |
|
226 | 226 |
public void test2() { |
... | ... | |
230 | 230 |
String source = "[1990] = 0.168873933773767"; |
231 | 231 |
|
232 | 232 |
Code code = compiler.compileExpression(source); |
233 |
assertEquals("=(\"1990\", 0.168873933773767)", code.toString());
|
|
233 |
assertEquals("(\"1990\" = 0.168873933773767)", code.toString());
|
|
234 | 234 |
} |
235 | 235 |
|
236 | 236 |
public void test2fields() { |
... | ... | |
240 | 240 |
String source = "[1990] = [precio]"; |
241 | 241 |
|
242 | 242 |
Code code = compiler.compileExpression(source); |
243 |
assertEquals("=(\"1990\", \"precio\")", code.toString());
|
|
243 |
assertEquals("(\"1990\" = \"precio\")", code.toString());
|
|
244 | 244 |
} |
245 | 245 |
|
246 | 246 |
|
trunk/org.gvsig.desktop/org.gvsig.desktop.library/org.gvsig.expressionevaluator/org.gvsig.expressionevaluator.lib/org.gvsig.expressionevaluator.lib.impl/src/test/java/org/gvsig/expresionevaluator/impl/TestExpressionBuilderFormatter.java | ||
---|---|---|
1 |
package org.gvsig.expresionevaluator.impl; |
|
2 |
|
|
3 |
import java.text.MessageFormat; |
|
4 |
import java.util.ArrayList; |
|
5 |
import java.util.List; |
|
6 |
import junit.framework.TestCase; |
|
7 |
import org.apache.commons.lang3.ArrayUtils; |
|
8 |
import org.apache.commons.lang3.StringUtils; |
|
9 |
import org.cresques.cts.IProjection; |
|
10 |
import org.gvsig.expressionevaluator.Formatter; |
|
11 |
import org.gvsig.expressionevaluator.ExpressionBuilder; |
|
12 |
import org.gvsig.expressionevaluator.ExpressionBuilder.Constant; |
|
13 |
import org.gvsig.expressionevaluator.ExpressionBuilder.Function; |
|
14 |
import org.gvsig.expressionevaluator.ExpressionBuilder.GeometrySupportType; |
|
15 |
import org.gvsig.expressionevaluator.ExpressionBuilder.Parameter; |
|
16 |
import org.gvsig.expressionevaluator.ExpressionBuilder.Value; |
|
17 |
import org.gvsig.expressionevaluator.ExpressionBuilder.Variable; |
|
18 |
import org.gvsig.expressionevaluator.impl.DefaultExpressionBuilder; |
|
19 |
import org.gvsig.fmap.crs.CRSFactory; |
|
20 |
import org.gvsig.fmap.geom.Geometry; |
|
21 |
import org.gvsig.fmap.geom.GeometryLocator; |
|
22 |
import org.gvsig.fmap.geom.GeometryManager; |
|
23 |
import org.gvsig.fmap.geom.GeometryUtils; |
|
24 |
import org.gvsig.fmap.geom.exception.CreateGeometryException; |
|
25 |
import org.gvsig.fmap.geom.primitive.Point; |
|
26 |
import org.gvsig.tools.library.impl.DefaultLibrariesInitializer; |
|
27 |
|
|
28 |
public class TestExpressionBuilderFormatter extends TestCase { |
|
29 |
|
|
30 |
private static class MyFormatter implements Formatter<Value> { |
|
31 |
|
|
32 |
private class Formatter_constant_bytearray implements Formatter<Value> { |
|
33 |
|
|
34 |
@Override |
|
35 |
public boolean canApply(Value value) { |
|
36 |
if( value instanceof Constant ) { |
|
37 |
return ((Constant)value).value() instanceof byte[]; |
|
38 |
} |
|
39 |
return false; |
|
40 |
} |
|
41 |
|
|
42 |
@Override |
|
43 |
public String format(Value constant) { |
|
44 |
return builder.bytearray_x((byte[]) ((Constant)constant).value()); |
|
45 |
} |
|
46 |
} |
|
47 |
|
|
48 |
private class Formatter_constant_geometry implements Formatter<Value> { |
|
49 |
|
|
50 |
@Override |
|
51 |
public boolean canApply(Value value) { |
|
52 |
if( value instanceof Constant ) { |
|
53 |
return ((Constant)value).value() instanceof Geometry; |
|
54 |
} |
|
55 |
return false; |
|
56 |
} |
|
57 |
|
|
58 |
@Override |
|
59 |
public String format(Value constant) { |
|
60 |
Geometry geometry = (Geometry) ((Constant)constant).value(); |
|
61 |
switch (builder.geometry_support_type()) { |
|
62 |
case EWKB: |
|
63 |
return MessageFormat.format( |
|
64 |
"ST_GeomFromEWKB(({0}), ({1}))", |
|
65 |
builder.bytearray_x(GeometryUtils.toEWKB(geometry)), |
|
66 |
String.valueOf(builder.srs_id(geometry.getProjection())) |
|
67 |
); |
|
68 |
case WKB: |
|
69 |
return MessageFormat.format( |
|
70 |
"ST_GeomFromWKB(({0}), ({1}))", |
|
71 |
builder.bytearray_x(GeometryUtils.toWKB(geometry)), |
|
72 |
String.valueOf(builder.srs_id(geometry.getProjection())) |
|
73 |
); |
|
74 |
case WKT: |
|
75 |
default: |
|
76 |
return MessageFormat.format( |
|
77 |
"ST_GeomFromText({0}, ({1}))", |
|
78 |
builder.string(GeometryUtils.toWKT(geometry)), |
|
79 |
String.valueOf(builder.srs_id(geometry.getProjection())) |
|
80 |
); |
|
81 |
} |
|
82 |
} |
|
83 |
} |
|
84 |
|
|
85 |
private class Formatter_ST_intersects implements Formatter<Value> { |
|
86 |
|
|
87 |
@Override |
|
88 |
public boolean canApply(Value value) { |
|
89 |
if( value instanceof Function ) { |
|
90 |
return StringUtils.equalsIgnoreCase("ST_intersects",((Function)value).name()); |
|
91 |
} |
|
92 |
return false; |
|
93 |
} |
|
94 |
|
|
95 |
@Override |
|
96 |
public String format(Value function) { |
|
97 |
List<Value> parameters = ((Function)function).parameters(); |
|
98 |
String p1 = parameters.get(0).toString(formatter()); |
|
99 |
String p2 = parameters.get(1).toString(formatter()); |
|
100 |
String r = MessageFormat.format( |
|
101 |
"( (({0}) && ({1})) AND ST_Intersects(({0}),({1}) ))", |
|
102 |
p1, |
|
103 |
p2 |
|
104 |
); |
|
105 |
return r; |
|
106 |
} |
|
107 |
} |
|
108 |
|
|
109 |
private class Formatter_ST_GeomFromEWKB implements Formatter<Value> { |
|
110 |
|
|
111 |
@Override |
|
112 |
public boolean canApply(Value value) { |
|
113 |
if( value instanceof Function ) { |
|
114 |
return StringUtils.equalsIgnoreCase("ST_GeomFromEWKB",((Function)value).name()); |
|
115 |
} |
|
116 |
return false; |
|
117 |
} |
|
118 |
|
|
119 |
@Override |
|
120 |
public String format(Value function) { |
|
121 |
List<Value> parameters = ((Function)function).parameters(); |
|
122 |
String p1 = parameters.get(0).toString(formatter()); |
|
123 |
String p2 = parameters.get(1).toString(formatter()); |
|
124 |
String r = MessageFormat.format( |
|
125 |
"GeomFromWKB({0}, {1})", |
|
126 |
p1, |
|
127 |
p2 |
|
128 |
); |
|
129 |
return r; |
|
130 |
} |
|
131 |
} |
|
132 |
|
|
133 |
private class Formatter_IFNULL implements Formatter<Value> { |
|
134 |
|
|
135 |
@Override |
|
136 |
public boolean canApply(Value value) { |
|
137 |
if( value instanceof Function ) { |
|
138 |
return StringUtils.equalsIgnoreCase("IFNULL",((Function)value).name()); |
|
139 |
} |
|
140 |
return false; |
|
141 |
} |
|
142 |
|
|
143 |
@Override |
|
144 |
public String format(Value function) { |
|
145 |
List<Value> parameters = ((Function)function).parameters(); |
|
146 |
String p1 = parameters.get(0).toString(formatter()); |
|
147 |
String p2 = parameters.get(1).toString(formatter()); |
|
148 |
String p3 = parameters.get(2).toString(formatter()); |
|
149 |
String r = MessageFormat.format( |
|
150 |
"NVL2({0}, {1}, {2})", |
|
151 |
p1, |
|
152 |
p3, |
|
153 |
p2 |
|
154 |
); |
|
155 |
return r; |
|
156 |
} |
|
157 |
} |
|
158 |
|
|
159 |
private class Formatter_ST_AsEWKB implements Formatter<Value> { |
|
160 |
|
|
161 |
@Override |
|
162 |
public boolean canApply(Value value) { |
|
163 |
if( value instanceof Function ) { |
|
164 |
return StringUtils.equalsIgnoreCase("ST_AsEWKB",((Function)value).name()); |
|
165 |
} |
|
166 |
return false; |
|
167 |
} |
|
168 |
|
|
169 |
public String format(Value function) { |
|
170 |
List<Value> parameters = ((Function)function).parameters(); |
|
171 |
String p1 = parameters.get(0).toString(formatter()); |
|
172 |
String r = MessageFormat.format( |
|
173 |
"AsWKB(({0}))", |
|
174 |
p1 |
|
175 |
); |
|
176 |
return r; |
|
177 |
} |
|
178 |
} |
|
179 |
|
|
180 |
private class Formatter_NOT_IS_NULL implements Formatter<Value> { |
|
181 |
|
|
182 |
@Override |
|
183 |
public boolean canApply(Value value) { |
|
184 |
if( value instanceof Function ) { |
|
185 |
return StringUtils.equalsIgnoreCase("NOT_IS_NULL",((Function)value).name()); |
|
186 |
} |
|
187 |
return false; |
|
188 |
} |
|
189 |
|
|
190 |
@Override |
|
191 |
public String format(Value function) { |
|
192 |
List<Value> parameters = ((Function)function).parameters(); |
|
193 |
String p1 = parameters.get(0).toString(MyFormatter.this); |
|
194 |
String r = MessageFormat.format( |
|
195 |
"( ({0}) IS NOT NULL )", |
|
196 |
p1 |
|
197 |
); |
|
198 |
return r; |
|
199 |
} |
|
200 |
} |
|
201 |
|
|
202 |
private final Formatter<Value>[] formatters; |
|
203 |
private final ExpressionBuilder builder; |
|
204 |
|
|
205 |
public MyFormatter(ExpressionBuilder builder) { |
|
206 |
this.builder = builder; |
|
207 |
this.formatters = new Formatter[] { |
|
208 |
new Formatter_IFNULL(), |
|
209 |
new Formatter_NOT_IS_NULL(), |
|
210 |
new Formatter_ST_AsEWKB(), |
|
211 |
new Formatter_ST_GeomFromEWKB(), |
|
212 |
new Formatter_constant_bytearray(), |
|
213 |
new Formatter_constant_geometry(), |
|
214 |
new Formatter_ST_intersects() |
|
215 |
}; |
|
216 |
} |
|
217 |
|
|
218 |
@Override |
|
219 |
public boolean canApply(Value value) { |
|
220 |
for (Formatter<Value> formatter : formatters) { |
|
221 |
if( formatter.canApply(value) ) { |
|
222 |
return true; |
|
223 |
} |
|
224 |
} |
|
225 |
return false; |
|
226 |
} |
|
227 |
|
|
228 |
@Override |
|
229 |
public String format(Value value) { |
|
230 |
for (Formatter<Value> formatter : formatters) { |
|
231 |
if( formatter.canApply(value) ) { |
|
232 |
return formatter.format(value); |
|
233 |
} |
|
234 |
} |
|
235 |
return value.toString(this); |
|
236 |
} |
|
237 |
|
|
238 |
private Formatter formatter() { |
|
239 |
return this; |
|
240 |
} |
|
241 |
} |
|
242 |
|
|
243 |
public TestExpressionBuilderFormatter(String testName) { |
|
244 |
super(testName); |
|
245 |
} |
|
246 |
|
|
247 |
@Override |
|
248 |
protected void setUp() throws Exception { |
|
249 |
super.setUp(); |
|
250 |
new DefaultLibrariesInitializer().fullInitialize(); |
|
251 |
} |
|
252 |
|
|
253 |
@Override |
|
254 |
protected void tearDown() throws Exception { |
|
255 |
super.tearDown(); |
|
256 |
} |
|
257 |
|
|
258 |
// TODO add test methods here. The name must begin with 'test'. For example: |
|
259 |
// public void testHello() {} |
|
260 |
|
|
261 |
List<String> getVariableNames(ExpressionBuilder builder) { |
|
262 |
List<String> vars = new ArrayList<>(); |
|
263 |
for (Variable var : builder.variables()) { |
|
264 |
vars.add(var.name()); |
|
265 |
} |
|
266 |
return vars; |
|
267 |
} |
|
268 |
|
|
269 |
List<String> getParameterNames(ExpressionBuilder builder) { |
|
270 |
List<String> params = new ArrayList<>(); |
|
271 |
for (Parameter param : builder.parameters()) { |
|
272 |
String s; |
|
273 |
switch(param.type()) { |
|
274 |
case Constant: |
|
275 |
Object value = param.value(); |
|
276 |
if( value==null ) { |
|
277 |
s = "null"; |
|
278 |
} else if( value instanceof String ) { |
|
279 |
s = "'" + (String)value + "'"; |
|
280 |
} else { |
|
281 |
s = value.toString(); |
|
282 |
} |
|
283 |
break; |
|
284 |
case Geometry: |
|
285 |
case Variable: |
Also available in: Unified diff