001: // Copyright (c) 2003-2007, Jodd Team (jodd.sf.net). All Rights Reserved.
002:
003: package jodd.db.orm;
004:
005: import static jodd.db.orm.sqlgen.DbSqlTemplate.ColumnAliasType.TABLE_NAME;
006: import static jodd.db.orm.sqlgen.DbSqlTemplate.ColumnAliasType.TABLE_REFERENCE;
007: import static jodd.db.orm.sqlgen.DbSqlTemplate.ColumnAliasType.COLUMN_CODE;
008: import junit.framework.TestCase;
009: import jodd.db.orm.sqlgen.DbSqlTemplate;
010: import jodd.db.orm.sqlgen.DbDynamicSqlTemplate;
011: import jodd.db.orm.test.Boy;
012: import jodd.db.orm.test.BadBoy;
013:
014: import java.util.Map;
015:
016: public class DbSqlTemplateTest extends TestCase {
017:
018: public void assertContains(String string, String... chunks) {
019: for (String chunk : chunks) {
020: assertTrue(string.indexOf(chunk) != -1);
021: }
022: }
023:
024: public void testTables() {
025: DbSqlTemplate t;
026:
027: // 1
028: t = new DbSqlTemplate("$T{jodd.db.orm.test.Boy}");
029: assertEquals("BOY Boy", t.generateQuery());
030: t = new DbSqlTemplate("$T{jodd.db.orm.test.Boy -}");
031: assertEquals("BOY", t.generateQuery());
032:
033: t = new DbSqlTemplate("$T{jodd.db.orm.test.BadBoy}");
034: assertEquals("BOY BadBoy", t.generateQuery());
035: t = new DbSqlTemplate("$T{jodd.db.orm.test.BadBoy -}");
036: assertEquals("BOY", t.generateQuery());
037:
038: t = new DbSqlTemplate("$T{jodd.db.orm.test.Boy b}");
039: assertEquals("BOY b", t.generateQuery());
040:
041: t = new DbSqlTemplate("$T{jodd.db.orm.test.BadBoy b}");
042: assertEquals("BOY b", t.generateQuery());
043:
044: // 2
045: t = new DbSqlTemplate("$T{b}").use("b", new Boy());
046: assertEquals("BOY b", t.generateQuery());
047: t = new DbSqlTemplate("$T{b -}").use("b", new Boy());
048: assertEquals("BOY", t.generateQuery());
049:
050: t = new DbSqlTemplate("$T{b}").use("b", new BadBoy());
051: assertEquals("BOY b", t.generateQuery());
052: t = new DbSqlTemplate("$T{b -}").use("b", new BadBoy());
053: assertEquals("BOY", t.generateQuery());
054:
055: t = new DbSqlTemplate("$T{b bb}").use("b", new Boy());
056: assertEquals("BOY bb", t.generateQuery());
057:
058: t = new DbSqlTemplate("$T{b bb}").use("b", new BadBoy());
059: assertEquals("BOY bb", t.generateQuery());
060:
061: // 3
062: t = new DbSqlTemplate("$T{b}").use("b", Boy.class);
063: assertEquals("BOY b", t.generateQuery());
064: t = new DbSqlTemplate("$T{b -}").use("b", Boy.class);
065: assertEquals("BOY", t.generateQuery());
066:
067: t = new DbSqlTemplate("$T{b}").use("b", BadBoy.class);
068: assertEquals("BOY b", t.generateQuery());
069: t = new DbSqlTemplate("$T{b -}").use("b", BadBoy.class);
070: assertEquals("BOY", t.generateQuery());
071:
072: t = new DbSqlTemplate("$T{b bb}").use("b", Boy.class);
073: assertEquals("BOY bb", t.generateQuery());
074:
075: t = new DbSqlTemplate("$T{b bb}").use("b", BadBoy.class);
076: assertEquals("BOY bb", t.generateQuery());
077:
078: }
079:
080: public void testColumns1() {
081: DbSqlTemplate t;
082:
083: // 1
084: t = new DbSqlTemplate(
085: "$T{jodd.db.orm.test.Boy} | $C{Boy.id} | $C{Boy.*} | $C{Boy}")
086: .columnAliases(false);
087: assertEquals(
088: "BOY Boy | Boy.ID | Boy.GIRL_ID, Boy.NAME, Boy.ID | GIRL_ID, NAME, ID",
089: t.generateQuery());
090: try {
091: t = new DbSqlTemplate(
092: "$T{jodd.db.orm.test.Boy -} | $C{Boy.id} | $C{Boy.*} | $C{Boy}")
093: .columnAliases(false);
094: t.generateQuery();
095: fail(); // because no reference is used!
096: } catch (DbOrmException dboex) {
097: }
098:
099: t = new DbSqlTemplate(
100: "$T{jodd.db.orm.test.BadBoy} | $C{BadBoy.ajdi} | $C{BadBoy.*} | $C{BadBoy}")
101: .columnAliases(false);
102: assertEquals(
103: "BOY BadBoy | BadBoy.ID | BadBoy.NAME, BadBoy.GIRL_ID, BadBoy.ID | NAME, GIRL_ID, ID",
104: t.generateQuery());
105:
106: t = new DbSqlTemplate(
107: "$T{jodd.db.orm.test.Boy b} | $C{b.id} | $C{b.*} | $C{b}")
108: .columnAliases(false);
109: assertEquals(
110: "BOY b | b.ID | b.GIRL_ID, b.NAME, b.ID | GIRL_ID, NAME, ID",
111: t.generateQuery());
112:
113: t = new DbSqlTemplate(
114: "$T{jodd.db.orm.test.BadBoy b} | $C{b.ajdi} | $C{b.*} | $C{b}")
115: .columnAliases(false);
116: assertEquals(
117: "BOY b | b.ID | b.NAME, b.GIRL_ID, b.ID | NAME, GIRL_ID, ID",
118: t.generateQuery());
119:
120: // 2
121: t = new DbSqlTemplate("$T{b} | $C{b.id} | $C{+b.*} | $C{+b}")
122: .use("b", new Boy()).columnAliases(false);
123: assertEquals(
124: "BOY b | b.ID | b.GIRL_ID, b.NAME, b.ID | GIRL_ID, NAME, ID",
125: t.generateQuery());
126:
127: t = new DbSqlTemplate("$T{b} | $C{b.ajdi} | $C{+b.*} | $C{+b}")
128: .use("b", new BadBoy()).columnAliases(false);
129: assertEquals(
130: "BOY b | b.ID | b.NAME, b.GIRL_ID, b.ID | NAME, GIRL_ID, ID",
131: t.generateQuery());
132:
133: t = new DbSqlTemplate(
134: "$T{b bb} | $C{bb.id} | $C{bb.*} | $C{bb}").use("b",
135: new Boy()).columnAliases(false);
136: assertEquals(
137: "BOY bb | bb.ID | bb.GIRL_ID, bb.NAME, bb.ID | GIRL_ID, NAME, ID",
138: t.generateQuery());
139:
140: t = new DbSqlTemplate(
141: "$T{b bb} | $C{bb.ajdi} | $C{bb.*} | $C{bb}").use("b",
142: new BadBoy()).columnAliases(false);
143: assertEquals(
144: "BOY bb | bb.ID | bb.NAME, bb.GIRL_ID, bb.ID | NAME, GIRL_ID, ID",
145: t.generateQuery());
146:
147: // 3
148: t = new DbSqlTemplate("$T{b} | $C{b.id} | $C{b.*} | $C{b}")
149: .use("b", Boy.class).columnAliases(false);
150: assertEquals(
151: "BOY b | b.ID | b.GIRL_ID, b.NAME, b.ID | GIRL_ID, NAME, ID",
152: t.generateQuery());
153:
154: t = new DbSqlTemplate("$T{b} | $C{b.ajdi} | $C{b.*} | $C{b}")
155: .use("b", BadBoy.class).columnAliases(false);
156: assertEquals(
157: "BOY b | b.ID | b.NAME, b.GIRL_ID, b.ID | NAME, GIRL_ID, ID",
158: t.generateQuery());
159:
160: t = new DbSqlTemplate(
161: "$T{b bb} | $C{bb.id} | $C{bb.*} | $C{bb}").use("b",
162: Boy.class).columnAliases(false);
163: assertEquals(
164: "BOY bb | bb.ID | bb.GIRL_ID, bb.NAME, bb.ID | GIRL_ID, NAME, ID",
165: t.generateQuery());
166:
167: t = new DbSqlTemplate(
168: "$T{b bb} | $C{bb.ajdi} | $C{bb.*} | $C{bb}").use("b",
169: BadBoy.class).columnAliases(false);
170: assertEquals(
171: "BOY bb | bb.ID | bb.NAME, bb.GIRL_ID, bb.ID | NAME, GIRL_ID, ID",
172: t.generateQuery());
173:
174: }
175:
176: public void testColumns2() {
177: DbSqlTemplate t;
178:
179: // 1
180: t = new DbSqlTemplate(
181: "$T{jodd.db.orm.test.Boy} | $C{Boy.id} | $C{Boy.*} | $C{Boy}")
182: .setColumnAliasesType(TABLE_NAME);
183: assertEquals(
184: "BOY Boy | Boy.ID as BOY$ID | Boy.GIRL_ID as BOY$GIRL_ID, Boy.NAME as BOY$NAME, Boy.ID as BOY$ID | GIRL_ID, NAME, ID",
185: t.generateQuery());
186: t = new DbSqlTemplate(
187: "$T{jodd.db.orm.test.Boy} | $C{Boy.id} | $C{Boy.*} | $C{Boy}")
188: .setColumnAliasesType(TABLE_REFERENCE);
189: assertEquals(
190: "BOY Boy | Boy.ID as Boy$ID | Boy.GIRL_ID as Boy$GIRL_ID, Boy.NAME as Boy$NAME, Boy.ID as Boy$ID | GIRL_ID, NAME, ID",
191: t.generateQuery());
192: t = new DbSqlTemplate(
193: "$T{jodd.db.orm.test.Boy} | $C{Boy.id} | $C{Boy.*} | $C{Boy}")
194: .setColumnAliasesType(COLUMN_CODE);
195: assertEquals(
196: "BOY Boy | Boy.ID as col_0_ | Boy.GIRL_ID as col_1_, Boy.NAME as col_2_, Boy.ID as col_3_ | GIRL_ID, NAME, ID",
197: t.generateQuery());
198:
199: t = new DbSqlTemplate(
200: "$T{jodd.db.orm.test.BadBoy} | $C{BadBoy.ajdi} | $C{BadBoy.*} | $C{BadBoy}")
201: .setColumnAliasesType(TABLE_NAME);
202: assertEquals(
203: "BOY BadBoy | BadBoy.ID as BOY$ID | BadBoy.NAME as BOY$NAME, BadBoy.GIRL_ID as BOY$GIRL_ID, BadBoy.ID as BOY$ID | NAME, GIRL_ID, ID",
204: t.generateQuery());
205: t = new DbSqlTemplate(
206: "$T{jodd.db.orm.test.BadBoy} | $C{BadBoy.ajdi} | $C{BadBoy.*} | $C{BadBoy}")
207: .setColumnAliasesType(TABLE_REFERENCE);
208: assertEquals(
209: "BOY BadBoy | BadBoy.ID as BadBoy$ID | BadBoy.NAME as BadBoy$NAME, BadBoy.GIRL_ID as BadBoy$GIRL_ID, BadBoy.ID as BadBoy$ID | NAME, GIRL_ID, ID",
210: t.generateQuery());
211: t = new DbSqlTemplate(
212: "$T{jodd.db.orm.test.BadBoy} | $C{BadBoy.ajdi} | $C{BadBoy.*} | $C{BadBoy}")
213: .setColumnAliasesType(COLUMN_CODE);
214: assertEquals(
215: "BOY BadBoy | BadBoy.ID as col_0_ | BadBoy.NAME as col_1_, BadBoy.GIRL_ID as col_2_, BadBoy.ID as col_3_ | NAME, GIRL_ID, ID",
216: t.generateQuery());
217:
218: // 2
219: t = new DbSqlTemplate("$T{b} | $C{b.id} | $C{+b.*} | $C{+b}")
220: .use("b", new Boy()).setColumnAliasesType(TABLE_NAME);
221: assertEquals(
222: "BOY b | b.ID as BOY$ID | b.GIRL_ID as BOY$GIRL_ID, b.NAME as BOY$NAME, b.ID as BOY$ID | GIRL_ID, NAME, ID",
223: t.generateQuery());
224: t = new DbSqlTemplate("$T{b} | $C{b.id} | $C{+b.*} | $C{+b}")
225: .use("b", new Boy()).setColumnAliasesType(
226: TABLE_REFERENCE);
227: assertEquals(
228: "BOY b | b.ID as b$ID | b.GIRL_ID as b$GIRL_ID, b.NAME as b$NAME, b.ID as b$ID | GIRL_ID, NAME, ID",
229: t.generateQuery());
230: t = new DbSqlTemplate("$T{b} | $C{b.id} | $C{+b.*} | $C{+b}")
231: .use("b", new Boy()).setColumnAliasesType(COLUMN_CODE);
232: assertEquals(
233: "BOY b | b.ID as col_0_ | b.GIRL_ID as col_1_, b.NAME as col_2_, b.ID as col_3_ | GIRL_ID, NAME, ID",
234: t.generateQuery());
235:
236: t = new DbSqlTemplate("$T{b} | $C{b.ajdi} | $C{+b.*} | $C{+b}")
237: .use("b", new BadBoy())
238: .setColumnAliasesType(TABLE_NAME);
239: assertEquals(
240: "BOY b | b.ID as BOY$ID | b.NAME as BOY$NAME, b.GIRL_ID as BOY$GIRL_ID, b.ID as BOY$ID | NAME, GIRL_ID, ID",
241: t.generateQuery());
242: t = new DbSqlTemplate("$T{b} | $C{b.ajdi} | $C{+b.*} | $C{+b}")
243: .use("b", new BadBoy()).setColumnAliasesType(
244: TABLE_REFERENCE);
245: assertEquals(
246: "BOY b | b.ID as b$ID | b.NAME as b$NAME, b.GIRL_ID as b$GIRL_ID, b.ID as b$ID | NAME, GIRL_ID, ID",
247: t.generateQuery());
248: t = new DbSqlTemplate("$T{b} | $C{b.ajdi} | $C{+b.*} | $C{+b}")
249: .use("b", new BadBoy()).setColumnAliasesType(
250: COLUMN_CODE);
251: assertEquals(
252: "BOY b | b.ID as col_0_ | b.NAME as col_1_, b.GIRL_ID as col_2_, b.ID as col_3_ | NAME, GIRL_ID, ID",
253: t.generateQuery());
254:
255: // 3
256: t = new DbSqlTemplate("$T{b} | $C{b.id} | $C{b.*} | $C{b}")
257: .use("b", Boy.class).setColumnAliasesType(TABLE_NAME);
258: assertEquals(
259: "BOY b | b.ID as BOY$ID | b.GIRL_ID as BOY$GIRL_ID, b.NAME as BOY$NAME, b.ID as BOY$ID | GIRL_ID, NAME, ID",
260: t.generateQuery());
261: t = new DbSqlTemplate("$T{b} | $C{b.id} | $C{b.*} | $C{b}")
262: .use("b", Boy.class).setColumnAliasesType(
263: TABLE_REFERENCE);
264: assertEquals(
265: "BOY b | b.ID as b$ID | b.GIRL_ID as b$GIRL_ID, b.NAME as b$NAME, b.ID as b$ID | GIRL_ID, NAME, ID",
266: t.generateQuery());
267: t = new DbSqlTemplate("$T{b} | $C{b.id} | $C{b.*} | $C{b}")
268: .use("b", Boy.class).setColumnAliasesType(COLUMN_CODE);
269: assertEquals(
270: "BOY b | b.ID as col_0_ | b.GIRL_ID as col_1_, b.NAME as col_2_, b.ID as col_3_ | GIRL_ID, NAME, ID",
271: t.generateQuery());
272:
273: t = new DbSqlTemplate("$T{b} | $C{b.ajdi} | $C{b.*} | $C{b}")
274: .use("b", BadBoy.class)
275: .setColumnAliasesType(TABLE_NAME);
276: assertEquals(
277: "BOY b | b.ID as BOY$ID | b.NAME as BOY$NAME, b.GIRL_ID as BOY$GIRL_ID, b.ID as BOY$ID | NAME, GIRL_ID, ID",
278: t.generateQuery());
279: }
280:
281: public void testColumns3() {
282: DbSqlTemplate t;
283:
284: t = new DbSqlTemplate("$C{b.id,b.name} from $T{b}").use("b",
285: Boy.class).columnAliases(false);
286: assertEquals("b.ID, b.NAME from BOY b", t.generateQuery());
287: t = new DbSqlTemplate(
288: "$C{ a.ajdi , a.nejm } from $T{b a}").use("b",
289: BadBoy.class).columnAliases(false);
290: assertEquals("a.ID, a.NAME from BOY a", t.generateQuery());
291:
292: t = new DbSqlTemplate("$C{b.id,b.name} from $T{b}").use("b",
293: Boy.class).setColumnAliasesType(TABLE_NAME);
294: assertEquals("b.ID as BOY$ID, b.NAME as BOY$NAME from BOY b", t
295: .generateQuery());
296: t = new DbSqlTemplate(
297: "$C{ a.ajdi , a.nejm } from $T{b a}").use("b",
298: BadBoy.class).setColumnAliasesType(TABLE_NAME);
299: assertEquals("a.ID as BOY$ID, a.NAME as BOY$NAME from BOY a", t
300: .generateQuery());
301:
302: t = new DbSqlTemplate("$b.id as d, $C{b.name} from $T{b}").use(
303: "b", Boy.class).setColumnAliasesType(TABLE_NAME);
304: assertEquals("b.ID as d, b.NAME as BOY$NAME from BOY b", t
305: .generateQuery());
306: t = new DbSqlTemplate(
307: "$a.ajdi as d, $C{ a.nejm } from $T{b a}").use(
308: "b", BadBoy.class).setColumnAliasesType(TABLE_NAME);
309: assertEquals("a.ID as d, a.NAME as BOY$NAME from BOY a", t
310: .generateQuery());
311:
312: t = new DbSqlTemplate("$C{*} from $T{b}").use("b", Boy.class);
313: try {
314: t.generateQuery();
315: fail();
316: } catch (DbOrmException doex) {
317: // ignore
318: }
319:
320: t = new DbSqlTemplate("$C{b.*} from $T{b}").use("b", Boy.class)
321: .setColumnAliasesType(TABLE_NAME);
322: assertEquals(
323: "b.GIRL_ID as BOY$GIRL_ID, b.NAME as BOY$NAME, b.ID as BOY$ID from BOY b",
324: t.generateQuery());
325: t = new DbSqlTemplate("$C{a.*} from $T{b a}").use("b",
326: BadBoy.class).columnAliases(false);
327: assertEquals("a.NAME, a.GIRL_ID, a.ID from BOY a", t
328: .generateQuery());
329:
330: t = new DbSqlTemplate(
331: "$C{a.*} from $T{jodd.db.orm.test.BadBoy a}")
332: .columnAliases(false);
333: assertEquals("a.NAME, a.GIRL_ID, a.ID from BOY a", t
334: .generateQuery());
335: t = new DbSqlTemplate(
336: "$C{BadBoy.ajdi} from $T{jodd.db.orm.test.BadBoy}")
337: .columnAliases(false);
338: assertEquals("BadBoy.ID from BOY BadBoy", t.generateQuery());
339:
340: }
341:
342: public void testColumnAliases() {
343: DbSqlTemplate t;
344:
345: t = new DbSqlTemplate(
346: "$T{jodd.db.orm.test.Boy} | $Boy.id as foo | $C{Boy.*} | $C{Boy}")
347: .columnAliases(false);
348: assertEquals(
349: "BOY Boy | Boy.ID as foo | Boy.GIRL_ID, Boy.NAME, Boy.ID | GIRL_ID, NAME, ID",
350: t.generateQuery());
351:
352: t = new DbSqlTemplate(
353: "$T{jodd.db.orm.test.BadBoy} | $BadBoy.ajdi as foo | $C{BadBoy.*} | $C{BadBoy}")
354: .setColumnAliasesType(TABLE_NAME);
355: assertEquals(
356: "BOY BadBoy | BadBoy.ID as foo | BadBoy.NAME as BOY$NAME, BadBoy.GIRL_ID as BOY$GIRL_ID, BadBoy.ID as BOY$ID | NAME, GIRL_ID, ID",
357: t.generateQuery());
358:
359: try {
360: t = new DbSqlTemplate(
361: "$T{jodd.db.orm.test.Boy} | $C{Boy.id as foo} | $Boy.* as foo | $C{Boy}")
362: .columnAliases(false);
363: t.generateQuery();
364: fail();
365: } catch (DbOrmException doex) {
366: }
367: }
368:
369: public void testColref() {
370: DbSqlTemplate t;
371: DbOrm.getInstance().setPackagePrefix("jodd.db.orm.test");
372:
373: t = new DbSqlTemplate(
374: "$T{.Boy, .BadBoy b} - \\$$Boy.id $b.ajdi");
375: assertEquals("BOY Boy, BOY b - $Boy.ID b.ID", t.generateQuery());
376:
377: t = new DbSqlTemplate(
378: "$C{b.ajdi} $T{.Boy, .BadBoy b} - \\$$Boy.id $b.ajdi")
379: .escape(true).setColumnAliasesType(TABLE_NAME);
380: assertEquals("b.ID as BOY$ID BOY Boy, BOY b - $Boy.ID b.ID", t
381: .generateQuery());
382:
383: t = new DbSqlTemplate(
384: "\\$C{b.ajdi} $T{.Boy, .BadBoy b} - \\$$Boy.id $b.ajdi")
385: .escape(true);
386: assertEquals("$C{b.ajdi} BOY Boy, BOY b - $Boy.ID b.ID", t
387: .generateQuery());
388:
389: t = new DbSqlTemplate("\\$C{b.*} $T{.Boy, .BadBoy b} - $Boy.id")
390: .escape(true);
391: assertEquals("$C{b.*} BOY Boy, BOY b - Boy.ID", t
392: .generateQuery());
393:
394: t = new DbSqlTemplate(
395: "$C{b.*} $T{.Boy, .BadBoy b} - $b.ajdi 'foo\\$'")
396: .escape(true).setColumnAliasesType(TABLE_NAME);
397: assertEquals(
398: "b.NAME as BOY$NAME, b.GIRL_ID as BOY$GIRL_ID, b.ID as BOY$ID BOY Boy, BOY b - b.ID 'foo$'",
399: t.generateQuery());
400:
401: t = new DbSqlTemplate(
402: "$T{.BadBoy b} - $b.ajdi=2,$b.ajdi<$b.ajdi").escape(
403: true).setColumnAliasesType(TABLE_NAME);
404: assertEquals("BOY b - b.ID=2,b.ID<b.ID", t.generateQuery());
405: }
406:
407: // ---------------------------------------------------------------- dynamics
408:
409: public void testWhere() {
410: DbDynamicSqlTemplate t;
411:
412: Boy boy = new Boy();
413: boy.id = 1;
414: boy.girlId = 3;
415: t = new DbDynamicSqlTemplate("$T{boy} $W{where boy}").use(
416: "boy", boy);
417: assertEquals(
418: "BOY boy where boy.GIRL_ID=:boy.girlId and boy.ID=:boy.id",
419: t.generateQuery());
420: Map map = t.getQueryParameters();
421: assertEquals(2, map.size());
422: assertEquals(Integer.valueOf(1), map.get("boy.id"));
423: assertEquals(Integer.valueOf(3), map.get("boy.girlId"));
424:
425: boy.id = 4;
426: boy.girlId = 1;
427: t = new DbDynamicSqlTemplate("$T{boy b} $W{where b2.boy}").use(
428: "boy", boy);
429: assertEquals(
430: "BOY b where b2.GIRL_ID=:boy.girlId and b2.ID=:boy.id",
431: t.generateQuery());
432: map = t.getQueryParameters();
433: assertEquals(2, map.size());
434: assertEquals(Integer.valueOf(4), map.get("boy.id"));
435: assertEquals(Integer.valueOf(1), map.get("boy.girlId"));
436:
437: boy.id = 4;
438: boy.girlId = 1;
439: t = new DbDynamicSqlTemplate("$T{boy b} $W{where .boy}").use(
440: "boy", boy);
441: assertEquals("BOY b where GIRL_ID=:boy.girlId and ID=:boy.id",
442: t.generateQuery());
443: map = t.getQueryParameters();
444: assertEquals(2, map.size());
445: assertEquals(Integer.valueOf(4), map.get("boy.id"));
446: assertEquals(Integer.valueOf(1), map.get("boy.girlId"));
447:
448: BadBoy badBoy = new BadBoy();
449: t = new DbDynamicSqlTemplate("$T{boy b} $W{where b.boy}").use(
450: "boy", badBoy);
451: assertEquals("BOY b ", t.generateQuery());
452: map = t.getQueryParameters();
453: assertEquals(0, map.size());
454:
455: badBoy.ajdi = Integer.valueOf(4);
456: badBoy.girlId = Integer.valueOf(1);
457: badBoy.ajdiGreaterEqual = Integer.valueOf(3);
458: badBoy.nejmLike = "x";
459: t = new DbDynamicSqlTemplate("$T{boy b} $W{where b.boy}").use(
460: "boy", badBoy);
461: assertEquals(
462: "BOY b where b.GIRL_ID=:badBoy.girlId and b.ID=:badBoy.ajdi",
463: t.generateQuery());
464: map = t.getQueryParameters();
465: assertEquals(2, map.size());
466: assertEquals(Integer.valueOf(4), map.get("badBoy.ajdi"));
467: assertEquals(Integer.valueOf(1), map.get("badBoy.girlId"));
468:
469: badBoy.ajdi = null;
470: t = new DbDynamicSqlTemplate("$T{boy b} $W{where !b.boy}").use(
471: "boy", badBoy);
472: assertEquals(
473: "BOY b where b.GIRL_ID=:badBoy.girlId and b.ID>=:badBoy.ajdiGreaterEqual and b.NAME like :badBoy.nejmLike",
474: t.generateQuery());
475: map = t.getQueryParameters();
476: assertEquals(3, map.size());
477: assertEquals(Integer.valueOf(3), map
478: .get("badBoy.ajdiGreaterEqual"));
479: assertEquals(Integer.valueOf(1), map.get("badBoy.girlId"));
480: assertEquals("x", map.get("badBoy.nejmLike"));
481: }
482:
483: public void testWhere2() {
484: DbDynamicSqlTemplate t;
485:
486: Boy boy = new Boy();
487: boy.id = 1;
488: boy.girlId = 3;
489: t = new DbDynamicSqlTemplate("$W{where boy}").use("boy", boy);
490: assertEquals(
491: "where boy.GIRL_ID=:boy.girlId and boy.ID=:boy.id", t
492: .generateQuery());
493: Map map = t.getQueryParameters();
494: assertEquals(2, map.size());
495: assertEquals(Integer.valueOf(1), map.get("boy.id"));
496: assertEquals(Integer.valueOf(3), map.get("boy.girlId"));
497:
498: t = new DbDynamicSqlTemplate("$W{where r.boy}").use("boy", boy);
499: assertEquals("where r.GIRL_ID=:boy.girlId and r.ID=:boy.id", t
500: .generateQuery());
501: map = t.getQueryParameters();
502: assertEquals(2, map.size());
503: assertEquals(Integer.valueOf(1), map.get("boy.id"));
504: assertEquals(Integer.valueOf(3), map.get("boy.girlId"));
505:
506: BadBoy badBoy = new BadBoy();
507: badBoy.ajdi = Integer.valueOf(1);
508: badBoy.girlId = Integer.valueOf(3);
509: t = new DbDynamicSqlTemplate("$W{where boy}")
510: .use("boy", badBoy);
511: assertEquals(
512: "where boy.GIRL_ID=:badBoy.girlId and boy.ID=:badBoy.ajdi",
513: t.generateQuery());
514: map = t.getQueryParameters();
515: assertEquals(2, map.size());
516: assertEquals(Integer.valueOf(1), map.get("badBoy.ajdi"));
517: assertEquals(Integer.valueOf(3), map.get("badBoy.girlId"));
518:
519: t = new DbDynamicSqlTemplate("$W{where r.boy}").use("boy",
520: badBoy);
521: assertEquals(
522: "where r.GIRL_ID=:badBoy.girlId and r.ID=:badBoy.ajdi",
523: t.generateQuery());
524: map = t.getQueryParameters();
525: assertEquals(2, map.size());
526: assertEquals(Integer.valueOf(1), map.get("badBoy.ajdi"));
527: assertEquals(Integer.valueOf(3), map.get("badBoy.girlId"));
528:
529: }
530:
531: public void testColumnsList() {
532: DbDynamicSqlTemplate t;
533:
534: t = new DbDynamicSqlTemplate(
535: "$C{Boy.*} $T{jodd.db.orm.test.Boy}")
536: .columnAliases(false);
537: assertEquals("Boy.GIRL_ID, Boy.NAME, Boy.ID BOY Boy", t
538: .generateQuery());
539:
540: t = new DbDynamicSqlTemplate(
541: "$C{+Boy.*} $T{jodd.db.orm.test.Boy}")
542: .columnAliases(false);
543: assertEquals("Boy.GIRL_ID, Boy.NAME, Boy.ID BOY Boy", t
544: .generateQuery());
545:
546: t = new DbDynamicSqlTemplate(
547: "$C{BadBoy.*} $T{jodd.db.orm.test.BadBoy}")
548: .columnAliases(false);
549: assertEquals(
550: "BadBoy.NAME, BadBoy.GIRL_ID, BadBoy.ID BOY BadBoy", t
551: .generateQuery());
552:
553: t = new DbDynamicSqlTemplate(
554: "$C{+BadBoy.*} $T{jodd.db.orm.test.BadBoy}")
555: .columnAliases(false);
556: assertEquals(
557: "BadBoy.NAME, BadBoy.GIRL_ID, BadBoy.ID BOY BadBoy", t
558: .generateQuery());
559:
560: t = new DbDynamicSqlTemplate("$C{Boy} $T{jodd.db.orm.test.Boy}");
561: assertEquals("GIRL_ID, NAME, ID BOY Boy", t.generateQuery());
562:
563: t = new DbDynamicSqlTemplate(
564: "$C{+BadBoy} $T{jodd.db.orm.test.BadBoy}")
565: .columnAliases(false);
566: assertEquals("NAME, GIRL_ID, ID BOY BadBoy", t.generateQuery());
567:
568: BadBoy badBoy = new BadBoy();
569: badBoy.nejm = "123";
570:
571: t = new DbDynamicSqlTemplate("$C{+boy.*} $T{boy}")
572: .columnAliases(false).use("boy", badBoy);
573: assertEquals("boy.NAME, boy.GIRL_ID, boy.ID BOY boy", t
574: .generateQuery());
575:
576: t = new DbDynamicSqlTemplate("$C{boy.*} $T{boy}")
577: .columnAliases(false).use("boy", badBoy);
578: assertEquals("boy.NAME BOY boy", t.generateQuery());
579:
580: t = new DbDynamicSqlTemplate("$C{+boy} $T{boy}").use("boy",
581: badBoy);
582: assertEquals("NAME, GIRL_ID, ID BOY boy", t.generateQuery());
583:
584: t = new DbDynamicSqlTemplate("$C{boy} $T{boy}").use("boy",
585: badBoy);
586: assertEquals("NAME BOY boy", t.generateQuery());
587: }
588:
589: public void testValues() {
590: DbDynamicSqlTemplate t;
591:
592: Boy boy = new Boy();
593: boy.id = 1;
594: boy.girlId = 3;
595:
596: t = new DbDynamicSqlTemplate("$V{boy}").use("boy", boy);
597: assertEquals(":boy.girlId, :boy.id", t.generateQuery());
598: Map map = t.getQueryParameters();
599: assertEquals(2, map.size());
600: assertEquals(Integer.valueOf(1), map.get("boy.id"));
601: assertEquals(Integer.valueOf(3), map.get("boy.girlId"));
602:
603: t = new DbDynamicSqlTemplate("$V{+boy}").use("boy", boy);
604: assertEquals(":boy.girlId, :boy.name, :boy.id", t
605: .generateQuery());
606: map = t.getQueryParameters();
607: assertEquals(3, map.size());
608: assertEquals(Integer.valueOf(1), map.get("boy.id"));
609: assertEquals(Integer.valueOf(3), map.get("boy.girlId"));
610: assertNull(map.get("boy.name"));
611:
612: BadBoy badBoy = new BadBoy();
613: t = new DbDynamicSqlTemplate("$V{boy}").use("boy", badBoy);
614: assertEquals("", t.generateQuery());
615: map = t.getQueryParameters();
616: assertEquals(0, map.size());
617:
618: t = new DbDynamicSqlTemplate("$V{+boy}").use("boy", badBoy);
619: assertEquals(":badBoy.nejm, :badBoy.girlId, :badBoy.ajdi", t
620: .generateQuery());
621: map = t.getQueryParameters();
622: assertEquals(3, map.size());
623: assertNull(map.get("boy.id"));
624: assertNull(map.get("boy.girlId"));
625: assertNull(map.get("boy.name"));
626:
627: badBoy.ajdi = Integer.valueOf(4);
628: badBoy.girlId = Integer.valueOf(1);
629: badBoy.ajdiGreaterEqual = Integer.valueOf(3);
630: badBoy.nejmLike = "x";
631: t = new DbDynamicSqlTemplate("$V{boy}").use("boy", badBoy);
632: assertEquals(":badBoy.girlId, :badBoy.ajdi", t.generateQuery());
633: map = t.getQueryParameters();
634: assertEquals(2, map.size());
635: assertEquals(Integer.valueOf(4), map.get("badBoy.ajdi"));
636: assertEquals(Integer.valueOf(1), map.get("badBoy.girlId"));
637:
638: t = new DbDynamicSqlTemplate("$V{+boy}").use("boy", badBoy);
639: assertEquals(":badBoy.nejm, :badBoy.girlId, :badBoy.ajdi", t
640: .generateQuery());
641: map = t.getQueryParameters();
642: assertEquals(3, map.size());
643: assertEquals(Integer.valueOf(4), map.get("badBoy.ajdi"));
644: assertEquals(Integer.valueOf(1), map.get("badBoy.girlId"));
645: assertNull(map.get("boy.name"));
646:
647: badBoy.ajdi = null;
648: t = new DbDynamicSqlTemplate("$V{boy}").use("boy", badBoy);
649: assertEquals(":badBoy.girlId", t.generateQuery());
650: map = t.getQueryParameters();
651: assertEquals(1, map.size());
652: assertEquals(Integer.valueOf(1), map.get("badBoy.girlId"));
653:
654: t = new DbDynamicSqlTemplate("$V{+boy}").use("boy", badBoy);
655: assertEquals(":badBoy.nejm, :badBoy.girlId, :badBoy.ajdi", t
656: .generateQuery());
657: map = t.getQueryParameters();
658: assertEquals(3, map.size());
659: assertNull(map.get("badBoy.ajdi"));
660: assertEquals(Integer.valueOf(1), map.get("badBoy.girlId"));
661: assertNull(map.get("boy.name"));
662:
663: }
664:
665: public void testUpdateSet() {
666: DbDynamicSqlTemplate t;
667:
668: Boy boy = new Boy();
669: boy.id = 1;
670: boy.girlId = 3;
671: t = new DbDynamicSqlTemplate("$U{boy}").use("boy", boy);
672: assertEquals("GIRL_ID=:boy.girlId, ID=:boy.id", t
673: .generateQuery());
674: Map map = t.getQueryParameters();
675: assertEquals(2, map.size());
676: assertEquals(Integer.valueOf(1), map.get("boy.id"));
677: assertEquals(Integer.valueOf(3), map.get("boy.girlId"));
678:
679: t = new DbDynamicSqlTemplate("$U{+boy}").use("boy", boy);
680: assertEquals("GIRL_ID=:boy.girlId, NAME=:boy.name, ID=:boy.id",
681: t.generateQuery());
682: map = t.getQueryParameters();
683: assertEquals(3, map.size());
684: assertEquals(Integer.valueOf(1), map.get("boy.id"));
685: assertEquals(Integer.valueOf(3), map.get("boy.girlId"));
686: assertNull(map.get("boy.name"));
687:
688: BadBoy badBoy = new BadBoy();
689: t = new DbDynamicSqlTemplate("$U{boy}").use("boy", badBoy);
690: assertEquals("", t.generateQuery());
691: map = t.getQueryParameters();
692: assertEquals(0, map.size());
693:
694: t = new DbDynamicSqlTemplate("$U{+boy}").use("boy", badBoy);
695: assertEquals(
696: "NAME=:badBoy.nejm, GIRL_ID=:badBoy.girlId, ID=:badBoy.ajdi",
697: t.generateQuery());
698: map = t.getQueryParameters();
699: assertEquals(3, map.size());
700:
701: badBoy.ajdi = Integer.valueOf(4);
702: badBoy.girlId = Integer.valueOf(1);
703: badBoy.ajdiGreaterEqual = Integer.valueOf(3);
704: badBoy.nejmLike = "x";
705: t = new DbDynamicSqlTemplate("$U{boy}").use("boy", badBoy);
706: assertEquals("GIRL_ID=:badBoy.girlId, ID=:badBoy.ajdi", t
707: .generateQuery());
708: map = t.getQueryParameters();
709: assertEquals(2, map.size());
710: assertEquals(Integer.valueOf(4), map.get("badBoy.ajdi"));
711: assertEquals(Integer.valueOf(1), map.get("badBoy.girlId"));
712:
713: t = new DbDynamicSqlTemplate("$U{+boy}").use("boy", badBoy);
714: assertEquals(
715: "NAME=:badBoy.nejm, GIRL_ID=:badBoy.girlId, ID=:badBoy.ajdi",
716: t.generateQuery());
717: map = t.getQueryParameters();
718: assertEquals(3, map.size());
719: assertEquals(Integer.valueOf(4), map.get("badBoy.ajdi"));
720: assertEquals(Integer.valueOf(1), map.get("badBoy.girlId"));
721: assertNull(map.get("boy.name"));
722: }
723:
724: }
|