1 package org.apache.torque;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.io.Serializable;
23
24 import org.apache.commons.lang.StringUtils;
25 import org.apache.commons.lang.builder.EqualsBuilder;
26 import org.apache.commons.lang.builder.HashCodeBuilder;
27
28
29
30
31
32
33
34 public class ColumnImpl implements Column, Serializable
35 {
36
37 private static final long serialVersionUID = 1L;
38
39
40 private static final String[] FUNCTION_DELIMITERS
41 = {" ", ",", "(", ")", "<", ">"};
42
43
44 private static final String DOT = ".";
45
46
47 private String columnName;
48
49
50 private String tableName;
51
52
53 private String schemaName;
54
55
56 private String sqlExpression;
57
58
59
60
61
62
63
64
65
66
67 public ColumnImpl(String tableName, String columnName)
68 {
69 if (columnName == null)
70 {
71 throw new NullPointerException("columnName must not be null");
72 }
73 if (tableName == null)
74 {
75 throw new NullPointerException("tableName must not be null");
76 }
77 setColumnName(columnName);
78 setTableName(tableName);
79 this.sqlExpression = tableName + DOT + columnName;
80 }
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96 public ColumnImpl(String schemaName, String tableName, String columnName)
97 {
98 if (columnName == null)
99 {
100 throw new NullPointerException("columnName must not be null");
101 }
102 setColumnName(columnName);
103 setTableName(tableName);
104 setSchemaName(schemaName);
105 if (this.tableName == null)
106 {
107 this.sqlExpression = this.columnName;
108 }
109 else
110 {
111 this.sqlExpression = this.tableName + DOT + this.columnName;
112 }
113 }
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131 public ColumnImpl(
132 String schemaName,
133 String tableName,
134 String columnName,
135 String sqlExpression)
136 {
137 setColumnName(columnName);
138 setTableName(tableName);
139 setSchemaName(schemaName);
140 setSqlExpression(sqlExpression);
141 }
142
143
144
145
146
147
148
149
150
151
152
153
154
155 public ColumnImpl(String sqlExpression)
156 {
157 setSqlExpression(sqlExpression);
158
159
160 int dotIndex = sqlExpression.lastIndexOf(DOT);
161 if (dotIndex == -1)
162 {
163 if (StringUtils.contains(sqlExpression, "*"))
164 {
165 return;
166 }
167 if (StringUtils.indexOfAny(sqlExpression, FUNCTION_DELIMITERS)
168 != -1)
169 {
170 throw new IllegalArgumentException("sqlExpression "
171 + sqlExpression
172 + " is unparseable, it does not contain a dot (.) "
173 + " but function delimiters.");
174 }
175 setColumnName(sqlExpression);
176 return;
177 }
178 String pre = sqlExpression.substring(0, dotIndex);
179 String post = sqlExpression.substring(
180 dotIndex + 1,
181 sqlExpression.length());
182 if (StringUtils.isBlank(pre))
183 {
184 throw new IllegalArgumentException("sqlExpression "
185 + sqlExpression
186 + " is blank before the dot (.)");
187 }
188 int startIndex = StringUtils.lastIndexOfAny(pre, FUNCTION_DELIMITERS);
189 int endIndex = StringUtils.indexOfAny(post, FUNCTION_DELIMITERS);
190 if (endIndex < 0)
191 {
192 endIndex = sqlExpression.length();
193 }
194 else
195 {
196
197 endIndex += dotIndex + 1;
198 }
199
200 if (startIndex + 1 == dotIndex)
201 {
202 throw new IllegalArgumentException("sqlExpression "
203 + sqlExpression
204 + " is blank between the last function delimiter ("
205 + StringUtils.join(FUNCTION_DELIMITERS)
206 + ") and the dot");
207 }
208 setColumnName(sqlExpression.substring(dotIndex + 1, endIndex));
209
210 String fullTableName
211 = sqlExpression.substring(startIndex + 1, dotIndex);
212 setTableName(fullTableName);
213 if (fullTableName.contains(DOT))
214 {
215 int fullTableNameDotIndex = fullTableName.lastIndexOf(DOT);
216 String extractedSchemaName
217 = fullTableName.substring(0, fullTableNameDotIndex);
218 setSchemaName(extractedSchemaName);
219 StringBuilder sqlExpressionBuilder = new StringBuilder();
220 if (startIndex != -1)
221 {
222 sqlExpressionBuilder.append(
223 sqlExpression.substring(0, startIndex + 1));
224 }
225 sqlExpressionBuilder.append(getTableName())
226 .append(DOT)
227 .append(post);
228 setSqlExpression(sqlExpressionBuilder.toString());
229 }
230 }
231
232
233
234
235
236
237 public String getColumnName()
238 {
239 return columnName;
240 }
241
242
243
244
245
246
247 private void setColumnName(String columnName)
248 {
249 if (columnName != null && StringUtils.isBlank(columnName))
250 {
251 throw new IllegalArgumentException("columnName must not be blank");
252 }
253 if ("*".equals(columnName))
254 {
255 this.columnName = null;
256 }
257 else
258 {
259 this.columnName = columnName;
260 }
261 }
262
263
264
265
266
267
268 public String getTableName()
269 {
270 return tableName;
271 }
272
273
274
275
276 public String getFullTableName()
277 {
278 if (schemaName != null)
279 {
280 return schemaName + '.' + tableName;
281 }
282 return tableName;
283 }
284
285
286
287
288
289
290
291
292
293
294
295 private void setTableName(String tableName)
296 {
297 if (tableName != null && StringUtils.isBlank(tableName))
298 {
299 throw new IllegalArgumentException("tableName must not be blank");
300 }
301 if (StringUtils.contains(tableName, DOT))
302 {
303 int dotIndex = tableName.lastIndexOf(DOT);
304 this.schemaName = tableName.substring(0, dotIndex);
305 this.tableName = tableName.substring(dotIndex + 1);
306 return;
307 }
308 this.tableName = tableName;
309 }
310
311
312
313
314
315
316
317 public String getSchemaName()
318 {
319 return schemaName;
320 }
321
322
323
324
325
326
327
328
329 private void setSchemaName(String schemaName)
330 {
331 if (schemaName == null)
332 {
333 return;
334 }
335 if (StringUtils.isBlank(schemaName))
336 {
337 throw new IllegalArgumentException("schemaName must not be blank");
338 }
339 this.schemaName = schemaName;
340 }
341
342
343
344
345 public String getSqlExpression()
346 {
347 return sqlExpression;
348 }
349
350
351
352
353
354
355
356
357
358 private void setSqlExpression(String sqlExpression)
359 {
360 if (sqlExpression == null)
361 {
362 throw new IllegalArgumentException(
363 "sqlExpression must not be null");
364 }
365 if (StringUtils.isBlank(sqlExpression))
366 {
367 throw new IllegalArgumentException(
368 "sqlExpression must not be blank");
369 }
370 this.sqlExpression = sqlExpression;
371 }
372
373 @Override
374 public int hashCode()
375 {
376 return new HashCodeBuilder()
377 .append(sqlExpression)
378 .append(columnName)
379 .append(tableName)
380 .append(schemaName)
381 .toHashCode();
382 }
383
384 @Override
385 public boolean equals(Object obj)
386 {
387 if (this == obj)
388 {
389 return true;
390 }
391 if (obj == null)
392 {
393 return false;
394 }
395 if (getClass() != obj.getClass())
396 {
397 return false;
398 }
399 ColumnImpl other = (ColumnImpl) obj;
400 return new EqualsBuilder()
401 .append(sqlExpression, other.sqlExpression)
402 .append(columnName, other.columnName)
403 .append(tableName, other.tableName)
404 .append(schemaName, other.schemaName)
405 .isEquals();
406 }
407
408 @Override
409 public String toString()
410 {
411 return "ColumnImpl [columnName=" + columnName
412 + ", tableName=" + tableName
413 + ", schemaName=" + schemaName
414 + ", sqlExpression=" + sqlExpression + "]";
415 }
416 }