1 package org.apache.torque.engine.database.model;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 import java.util.ArrayList;
20 import java.util.Iterator;
21 import java.util.List;
22
23 import org.apache.commons.lang.StringUtils;
24 import org.apache.commons.logging.Log;
25 import org.apache.commons.logging.LogFactory;
26 import org.apache.torque.engine.EngineException;
27 import org.apache.torque.engine.platform.Platform;
28 import org.apache.torque.engine.platform.PlatformDefaultImpl;
29 import org.xml.sax.Attributes;
30
31 /***
32 * A Class for holding data about a column used in an Application.
33 *
34 * @author <a href="mailto:leon@opticode.co.za">Leon Messerschmidt</a>
35 * @author <a href="mailto:jvanzyl@apache.org">Jason van Zyl</a>
36 * @author <a href="mailto:jon@latchkey.com">Jon S. Stevens</a>
37 * @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
38 * @author <a href="mailto:byron_foster@byron_foster@yahoo.com>Byron Foster</a>
39 * @author <a href="mailto:mpoeschl@marmot.at>Martin Poeschl</a>
40 * @version $Id: Column.java,v 1.29 2005/06/27 21:34:10 tfischer Exp $
41 */
42 public class Column
43 {
44 private static final SchemaType DEFAULT_TYPE = SchemaType.VARCHAR;
45 /*** Logging class from commons.logging */
46 private static Log log = LogFactory.getLog(Column.class);
47 private String name;
48 private String description;
49 private Domain domain = new Domain();
50 private String javaName = null;
51 private String javaNamingMethod;
52 private boolean isNotNull = false;
53 private boolean isProtected = false;
54 private String javaType;
55 private Table parentTable;
56 private int position;
57 private boolean isPrimaryKey = false;
58 private boolean isUnique = false;
59 private boolean isAutoIncrement = false;
60 private List referrers;
61
62
63
64
65 private String inheritanceType;
66 private boolean isInheritance;
67 private boolean isEnumeratedClasses;
68 private List inheritanceList;
69 private boolean needsTransactionInPostgres;
70
71 /*** generate is... setters for boolean columns if true */
72 private boolean correctGetters = false;
73
74 /*** class name to do input validation on this column */
75 private String inputValidator = null;
76
77 /***
78 * Creates a new instance with a <code>null</code> name.
79 */
80 public Column()
81 {
82 this(null);
83 }
84
85 /***
86 * Creates a new column and set the name
87 *
88 * @param name column name
89 */
90 public Column(String name)
91 {
92 this.name = name;
93 }
94
95 /***
96 * Return a comma delimited string listing the specified columns.
97 *
98 * @param columns Either a list of <code>Column</code> objects, or
99 * a list of <code>String</code> objects with column names.
100 */
101 public static String makeList(List columns)
102 {
103 Object obj = columns.get(0);
104 boolean isColumnList = (obj instanceof Column);
105 if (isColumnList)
106 {
107 obj = ((Column) obj).getName();
108 }
109 StringBuffer buf = new StringBuffer((String) obj);
110 for (int i = 1; i < columns.size(); i++)
111 {
112 obj = columns.get(i);
113 if (isColumnList)
114 {
115 obj = ((Column) obj).getName();
116 }
117 buf.append(", ").append(obj);
118 }
119 return buf.toString();
120 }
121
122 /***
123 * Imports a column from an XML specification
124 */
125 public void loadFromXML(Attributes attrib)
126 {
127 String dom = attrib.getValue("domain");
128 if (StringUtils.isNotEmpty(dom))
129 {
130 domain = new Domain(getTable().getDatabase().getDomain(dom));
131 }
132 else
133 {
134 domain = new Domain(getPlatform().getDomainForSchemaType(DEFAULT_TYPE));
135 setType(attrib.getValue("type"));
136 }
137
138 name = attrib.getValue("name");
139
140 javaName = attrib.getValue("javaName");
141 javaType = attrib.getValue("javaType");
142 if (javaType != null && javaType.length() == 0)
143 {
144 javaType = null;
145 }
146
147
148
149 javaNamingMethod = attrib.getValue("javaNamingMethod");
150 if (javaNamingMethod == null)
151 {
152 javaNamingMethod
153 = parentTable.getDatabase().getDefaultJavaNamingMethod();
154 }
155
156
157 String primaryKey = attrib.getValue("primaryKey");
158
159 isPrimaryKey = ("true".equals(primaryKey));
160
161
162 if ("true".equals(primaryKey))
163 {
164 isNotNull = true;
165 }
166
167
168
169 String notNull = attrib.getValue("required");
170 isNotNull = (notNull != null && "true".equals(notNull));
171
172
173 String autoIncrement = attrib.getValue("autoIncrement");
174
175
176
177
178
179 isAutoIncrement = ("true".equals(autoIncrement)
180 || (isPrimaryKey()
181 && IDMethod.NATIVE.equals(getTable().getIdMethod())
182 && Platform.IDENTITY.equals(
183 getPlatform().getNativeIdMethod())
184 && (!"false".equals(autoIncrement))));
185
186 domain.replaceDefaultValue(attrib.getValue("default"));
187
188 domain.replaceSize(attrib.getValue("size"));
189 domain.replaceScale(attrib.getValue("scale"));
190
191 inheritanceType = attrib.getValue("inheritance");
192 isInheritance = (inheritanceType != null
193 && !inheritanceType.equals("false"));
194
195 this.inputValidator = attrib.getValue("inputValidator");
196 description = attrib.getValue("description");
197
198 isProtected = ("true".equals(attrib.getValue("protected")));
199 }
200
201 /***
202 * Returns table.column
203 */
204 public String getFullyQualifiedName()
205 {
206 return (parentTable.getName() + '.' + name);
207 }
208
209 /***
210 * Get the name of the column
211 */
212 public String getName()
213 {
214 return name;
215 }
216
217 /***
218 * Set the name of the column
219 */
220 public void setName(String newName)
221 {
222 name = newName;
223 }
224
225 /***
226 * Get the description for the Table
227 */
228 public String getDescription()
229 {
230 return description;
231 }
232
233 /***
234 * Set the description for the Table
235 *
236 * @param newDescription description for the Table
237 */
238 public void setDescription(String newDescription)
239 {
240 description = newDescription;
241 }
242
243 /***
244 * Get name to use in Java sources to build method names.
245 *
246 * @return the capitalised javaName
247 */
248 public String getJavaName()
249 {
250 if (javaName == null)
251 {
252 List inputs = new ArrayList(2);
253 inputs.add(name);
254 inputs.add(javaNamingMethod);
255 try
256 {
257 javaName = NameFactory.generateName(NameFactory.JAVA_GENERATOR,
258 inputs);
259 }
260 catch (EngineException e)
261 {
262 log.error(e, e);
263 }
264 }
265 return StringUtils.capitalize(javaName);
266 }
267
268 /***
269 * Returns the name for the getter method to retrieve the value of this
270 * column
271 *
272 * @return A getter method name for this column.
273 * @since 3.2
274 */
275 public String getGetterName()
276 {
277 if (("boolean".equalsIgnoreCase(getJavaNative()) && isCorrectGetters()))
278 {
279 return "is" + StringUtils.capitalize(getJavaName());
280 }
281 else
282 {
283 return "get" + StringUtils.capitalize(getJavaName());
284 }
285 }
286
287 /***
288 * Returns the name for the setter method to set the value of this
289 * column
290 *
291 * @return A setter method name for this column.
292 * @since 3.2
293 */
294 public String getSetterName()
295 {
296 return "set" + StringUtils.capitalize(getJavaName());
297 }
298
299 /***
300 * Get variable name to use in Java sources (= uncapitalised java name)
301 */
302 public String getUncapitalisedJavaName()
303 {
304 return StringUtils.uncapitalize(getJavaName());
305 }
306
307 /***
308 * Set name to use in Java sources
309 */
310 public void setJavaName(String javaName)
311 {
312 this.javaName = javaName;
313 }
314
315 /***
316 * Get type to use in Java sources
317 */
318 public String getJavaType()
319 {
320 return javaType;
321 }
322
323 /***
324 * Get the location of this column within the table (one-based).
325 * @return value of position.
326 */
327 public int getPosition()
328 {
329 return position;
330 }
331
332 /***
333 * Get the location of this column within the table (one-based).
334 * @param v Value to assign to position.
335 */
336 public void setPosition(int v)
337 {
338 this.position = v;
339 }
340
341 /***
342 * Set the parent Table of the column
343 */
344 public void setTable(Table parent)
345 {
346 parentTable = parent;
347 }
348
349 /***
350 * Get the parent Table of the column
351 */
352 public Table getTable()
353 {
354 return parentTable;
355 }
356
357 /***
358 * Returns the Name of the table the column is in
359 */
360 public String getTableName()
361 {
362 return parentTable.getName();
363 }
364
365 /***
366 * A utility function to create a new column
367 * from attrib and add it to this table.
368 */
369 public Inheritance addInheritance(Attributes attrib)
370 {
371 Inheritance inh = new Inheritance();
372 inh.loadFromXML (attrib);
373 addInheritance(inh);
374
375 return inh;
376 }
377
378 /***
379 * Adds a new inheritance definition to the inheritance list and set the
380 * parent column of the inheritance to the current column
381 */
382 public void addInheritance(Inheritance inh)
383 {
384 inh.setColumn(this);
385 if (inheritanceList == null)
386 {
387 inheritanceList = new ArrayList();
388 isEnumeratedClasses = true;
389 }
390 inheritanceList.add(inh);
391 }
392
393 /***
394 * Get the inheritance definitions.
395 */
396 public List getChildren()
397 {
398 return inheritanceList;
399 }
400
401 /***
402 * Determine if this column is a normal property or specifies a
403 * the classes that are represented in the table containing this column.
404 */
405 public boolean isInheritance()
406 {
407 return isInheritance;
408 }
409
410 /***
411 * Determine if possible classes have been enumerated in the xml file.
412 */
413 public boolean isEnumeratedClasses()
414 {
415 return isEnumeratedClasses;
416 }
417
418 /***
419 * Return the isNotNull property of the column
420 */
421 public boolean isNotNull()
422 {
423 return isNotNull;
424 }
425
426 /***
427 * Set the isNotNull property of the column
428 */
429 public void setNotNull(boolean status)
430 {
431 isNotNull = status;
432 }
433
434 /***
435 * Return NOT NULL String for this column
436 *
437 * @return "NOT NULL" if null values are not allowed or an empty String.
438 */
439 public String getNotNullString()
440 {
441 return getTable().getDatabase().getPlatform()
442 .getNullString(this.isNotNull());
443 }
444
445 /***
446 * Return the isProtected property of the column
447 */
448 public boolean isProtected()
449 {
450 return isProtected;
451 }
452
453 /***
454 * Set the isProtected property of the Column
455 */
456 public void setProtected(boolean prot)
457 {
458 isProtected = prot;
459 }
460
461 /***
462 * Set if the column is a primary key or not
463 */
464 public void setPrimaryKey(boolean pk)
465 {
466 isPrimaryKey = pk;
467 }
468
469 /***
470 * Return true if the column is a primary key
471 */
472 public boolean isPrimaryKey()
473 {
474 return isPrimaryKey;
475 }
476
477 /***
478 * Set true if the column is UNIQUE
479 */
480 public void setUnique (boolean u)
481 {
482 isUnique = u;
483 }
484
485 /***
486 * Get the UNIQUE property
487 */
488 public boolean isUnique()
489 {
490 return isUnique;
491 }
492
493 /***
494 * Return true if the column requires a transaction in Postgres
495 */
496 public boolean requiresTransactionInPostgres()
497 {
498 return needsTransactionInPostgres;
499 }
500
501 /***
502 * Utility method to determine if this column is a foreign key.
503 */
504 public boolean isForeignKey()
505 {
506 return (getForeignKey() != null);
507 }
508
509 /***
510 * Determine if this column is a foreign key that refers to the
511 * same table as another foreign key column in this table.
512 */
513 public boolean isMultipleFK()
514 {
515 ForeignKey fk = getForeignKey();
516 if (fk != null)
517 {
518 Iterator fks = parentTable.getForeignKeys().iterator();
519 while (fks.hasNext())
520 {
521 ForeignKey key = (ForeignKey) fks.next();
522 if (key.getForeignTableName().equals(fk.getForeignTableName())
523 && !key.getLocalColumns().contains(this.name))
524 {
525 return true;
526 }
527 }
528 }
529
530
531 return false;
532 }
533
534 /***
535 * get the foreign key object for this column
536 * if it is a foreign key or part of a foreign key
537 */
538 public ForeignKey getForeignKey()
539 {
540 return parentTable.getForeignKey(this.name);
541 }
542
543 /***
544 * Utility method to get the related table of this column if it is a foreign
545 * key or part of a foreign key
546 */
547 public String getRelatedTableName()
548 {
549 ForeignKey fk = getForeignKey();
550 return (fk == null ? null : fk.getForeignTableName());
551 }
552
553 /***
554 * Utility method to get the related column of this local column if this
555 * column is a foreign key or part of a foreign key.
556 */
557 public String getRelatedColumnName()
558 {
559 ForeignKey fk = getForeignKey();
560 if (fk == null)
561 {
562 return null;
563 }
564 else
565 {
566 return fk.getLocalForeignMapping().get(this.name).toString();
567 }
568 }
569
570 /***
571 * Adds the foreign key from another table that refers to this column.
572 */
573 public void addReferrer(ForeignKey fk)
574 {
575 if (referrers == null)
576 {
577 referrers = new ArrayList(5);
578 }
579 referrers.add(fk);
580 }
581
582 /***
583 * Get list of references to this column.
584 */
585 public List getReferrers()
586 {
587 if (referrers == null)
588 {
589 referrers = new ArrayList(5);
590 }
591 return referrers;
592 }
593
594 /***
595 * Sets the colunm type
596 */
597 public void setType(String torqueType)
598 {
599 SchemaType type = SchemaType.getEnum(torqueType);
600 if (type == null)
601 {
602 log.warn("SchemaType " + torqueType + " does not exist");
603 type = Column.DEFAULT_TYPE;
604 }
605 setType(type);
606 }
607
608 /***
609 * Sets the colunm type
610 */
611 public void setType(SchemaType torqueType)
612 {
613 domain = new Domain(getPlatform().getDomainForSchemaType(torqueType));
614 if (torqueType.equals(SchemaType.VARBINARY)
615 || torqueType.equals(SchemaType.BLOB))
616 {
617 needsTransactionInPostgres = true;
618 }
619 }
620
621 /***
622 * Returns the column jdbc type as an object
623 *
624 * @deprecated the type conversion is handled by the platform package
625 * (since torque 3.2)
626 */
627 public Object getType()
628 {
629 return TypeMap.getJdbcType(domain.getType()).getName();
630 }
631
632 /***
633 * Returns the column type as given in the schema as an object
634 */
635 public Object getTorqueType()
636 {
637 return domain.getType().getName();
638 }
639
640 /***
641 * Utility method to see if the column is a string
642 *
643 * @deprecated will be removed after the 3.2 release
644 */
645 public boolean isString()
646 {
647 return (domain.getType().getName().indexOf ("CHAR") != -1);
648 }
649
650 /***
651 * Utility method to return the value as an element to be usable
652 * in an SQL insert statement. This is used from the SQL loader task
653 */
654 public boolean needEscapedValue()
655 {
656 String torqueType = domain.getType().getName();
657 return (torqueType != null) && (torqueType.equals("VARCHAR")
658 || torqueType.equals("LONGVARCHAR")
659 || torqueType.equals("DATE")
660 || torqueType.equals("DATETIME")
661 || torqueType.equals("TIMESTAMP")
662 || torqueType.equals("TIME")
663 || torqueType.equals("CHAR")
664 || torqueType.equals("CLOB"));
665 }
666
667 /***
668 * String representation of the column. This is an xml representation.
669 *
670 * @return string representation in xml
671 */
672 public String toString()
673 {
674 StringBuffer result = new StringBuffer();
675 result.append(" <column name=\"").append(name).append('"');
676
677 if (javaName != null)
678 {
679 result.append(" javaName=\"").append(javaName).append('"');
680 }
681
682 if (isPrimaryKey)
683 {
684 result.append(" primaryKey=\"").append(isPrimaryKey).append('"');
685 }
686
687 if (isNotNull)
688 {
689 result.append(" required=\"true\"");
690 }
691 else
692 {
693 result.append(" required=\"false\"");
694 }
695
696 result.append(" type=\"").append(domain.getType().getName()).append('"');
697
698 if (domain.getSize() != null)
699 {
700 result.append(" size=\"").append(domain.getSize()).append('"');
701 }
702
703 if (domain.getScale() != null)
704 {
705 result.append(" scale=\"").append(domain.getScale()).append('"');
706 }
707
708 if (domain.getDefaultValue() != null)
709 {
710 result.append(" default=\"").append(domain.getDefaultValue()).append('"');
711 }
712
713 if (isInheritance())
714 {
715 result.append(" inheritance=\"").append(inheritanceType)
716 .append('"');
717 }
718
719
720 result.append(" />\n");
721
722 return result.toString();
723 }
724
725 /***
726 * Returns the size of the column
727 */
728 public String getSize()
729 {
730 return domain.getSize();
731 }
732
733 /***
734 * Set the size of the column
735 */
736 public void setSize(String newSize)
737 {
738 domain.setSize(newSize);
739 }
740
741 /***
742 * Returns the scale of the column
743 */
744 public String getScale()
745 {
746 return domain.getScale();
747 }
748
749 /***
750 * Set the scale of the column
751 */
752 public void setScale(String newScale)
753 {
754 domain.setScale(newScale);
755 }
756
757 /***
758 * Return the size and scale in brackets for use in an sql schema.
759 *
760 * @return size and scale or an empty String if there are no values
761 * available.
762 */
763 public String printSize()
764 {
765 return domain.printSize();
766 }
767
768 /***
769 * Return a string that will give this column a default value.
770 * @deprecated
771 */
772 public String getDefaultSetting()
773 {
774 return domain.getDefaultSetting();
775 }
776
777 /***
778 * Set a string that will give this column a default value.
779 */
780 public void setDefaultValue(String def)
781 {
782 domain.setDefaultValue(def);
783 }
784
785 /***
786 * Get a string that will give this column a default value.
787 */
788 public String getDefaultValue()
789 {
790 return domain.getDefaultValue();
791 }
792
793 /***
794 * Returns the class name to do input validation
795 */
796 public String getInputValidator()
797 {
798 return this.inputValidator;
799 }
800
801 /***
802 * Return auto increment/sequence string for the target database. We need to
803 * pass in the props for the target database!
804 */
805 public boolean isAutoIncrement()
806 {
807 return isAutoIncrement;
808 }
809
810 /***
811 * Set the auto increment value.
812 * Use isAutoIncrement() to find out if it is set or not.
813 */
814 public void setAutoIncrement(boolean value)
815 {
816 isAutoIncrement = value;
817 }
818
819 public String getAutoIncrementString()
820 {
821 if (isAutoIncrement()
822 && IDMethod.NATIVE.equals(getTable().getIdMethod()))
823 {
824 return getPlatform().getAutoIncrement();
825 }
826 return "";
827 }
828
829 /***
830 * Set the column type from a string property
831 * (normally a string from an sql input file)
832 */
833 public void setTypeFromString(String typeName, String size)
834 {
835 String tn = typeName.toUpperCase();
836 setType(tn);
837
838 if (size != null)
839 {
840 domain.setSize(size);
841 }
842
843 if (tn.indexOf("CHAR") != -1)
844 {
845 domain.setType(SchemaType.VARCHAR);
846 }
847 else if (tn.indexOf("INT") != -1)
848 {
849 domain.setType(SchemaType.INTEGER);
850 }
851 else if (tn.indexOf("FLOAT") != -1)
852 {
853 domain.setType(SchemaType.FLOAT);
854 }
855 else if (tn.indexOf("DATE") != -1)
856 {
857 domain.setType(SchemaType.DATE);
858 }
859 else if (tn.indexOf("TIME") != -1)
860 {
861 domain.setType(SchemaType.TIMESTAMP);
862 }
863 else if (tn.indexOf("BINARY") != -1)
864 {
865 domain.setType(SchemaType.LONGVARBINARY);
866 }
867 else
868 {
869 domain.setType(SchemaType.VARCHAR);
870 }
871 }
872
873 /***
874 * Return a string representation of the
875 * Java object which corresponds to the JDBC
876 * type of this column. Use in the generation
877 * of MapBuilders.
878 */
879 public String getJavaObject()
880 {
881 return TypeMap.getJavaObject(domain.getType());
882 }
883
884 /***
885 * Return a string representation of the primitive java type which
886 * corresponds to the JDBC type of this column.
887 *
888 * @return string representation of the primitive java type
889 */
890 public String getJavaPrimitive()
891 {
892 return TypeMap.getJavaNative(domain.getType());
893 }
894
895 /***
896 * Return a string representation of the native java type which corresponds
897 * to the JDBC type of this column. Use in the generation of Base objects.
898 * This method is used by torque, so it returns Key types for primaryKey and
899 * foreignKey columns
900 *
901 * @return java datatype used by torque
902 */
903 public String getJavaNative()
904 {
905 String jtype = TypeMap.getJavaNativeObject(domain.getType());
906 if (isUsePrimitive())
907 {
908 jtype = TypeMap.getJavaNative(domain.getType());
909 }
910
911 return jtype;
912 }
913
914 /***
915 * Return Village asX() method which corresponds to the JDBC type
916 * which represents this column.
917 */
918 public String getVillageMethod()
919 {
920 String vmethod = TypeMap.getVillageObjectMethod(domain.getType());
921 if (isUsePrimitive())
922 {
923 vmethod = TypeMap.getVillageMethod(domain.getType());
924 }
925
926 return vmethod;
927 }
928
929 /***
930 * Return ParameterParser getX() method which
931 * corresponds to the JDBC type which represents this column.
932 */
933 public String getParameterParserMethod()
934 {
935 return TypeMap.getPPMethod(domain.getType());
936 }
937
938 /***
939 * Returns true if the column type is boolean in the
940 * java object and a numeric (1 or 0) in the db.
941 */
942 public boolean isBooleanInt()
943 {
944 return TypeMap.isBooleanInt(domain.getType());
945 }
946
947 /***
948 * Returns true if the column type is boolean in the
949 * java object and a String ("Y" or "N") in the db.
950 */
951 public boolean isBooleanChar()
952 {
953 return TypeMap.isBooleanChar(domain.getType());
954 }
955
956 /***
957 * Returns true if the column type is boolean in the
958 * java object and a Bit ("1" or "0") in the db.
959 */
960 public boolean isBit()
961 {
962 return TypeMap.isBit(domain.getType());
963 }
964
965 /***
966 * returns true, if the columns java native type is an
967 * boolean, byte, short, int, long, float, double, char
968 */
969 public boolean isPrimitive()
970 {
971 String t = getJavaNative();
972 return "boolean".equals(t)
973 || "byte".equals(t)
974 || "short".equals(t)
975 || "int".equals(t)
976 || "long".equals(t)
977 || "float".equals(t)
978 || "double".equals(t)
979 || "char".equals(t);
980 }
981
982 public boolean isUsePrimitive()
983 {
984 String s = getJavaType();
985 return (s != null && s.equals("primitive"))
986 || (s == null && !"object".equals(
987 getTable().getDatabase().getDefaultJavaType()));
988 }
989
990 /***
991 * @return Returns the domain.
992 */
993 public Domain getDomain()
994 {
995 return domain;
996 }
997
998 /***
999 * @param domain The domain to set.
1000 */
1001 public void setDomain(Domain domain)
1002 {
1003 this.domain = domain;
1004 }
1005
1006 private Platform getPlatform()
1007 {
1008 try
1009 {
1010 return getTable().getDatabase().getPlatform();
1011 }
1012 catch (Exception ex)
1013 {
1014 log.warn("could not load platform implementation");
1015 }
1016 return new PlatformDefaultImpl();
1017 }
1018
1019 public String getSqlString()
1020 {
1021 StringBuffer sb = new StringBuffer();
1022 sb.append(getName());
1023 sb.append(' ');
1024 sb.append(getDomain().getSqlType());
1025 if (getPlatform().hasSize(getDomain().getSqlType()))
1026 {
1027 sb.append(getDomain().printSize());
1028 sb.append(' ');
1029 }
1030 if (getDomain().getDefaultValue() != null)
1031 {
1032 sb.append("default ");
1033 if (TypeMap.isTextType(getDomain().getType()))
1034 {
1035
1036 sb.append('\'').append(getDefaultValue()).append('\'');
1037 }
1038 else
1039 {
1040 sb.append(getDefaultValue());
1041 }
1042 sb.append(' ');
1043 }
1044 sb.append(getNotNullString());
1045 sb.append(' ');
1046 sb.append(getAutoIncrementString());
1047 return sb.toString();
1048 }
1049
1050 /***
1051 * Return the correctGetters property of the column
1052 *
1053 * @return The currentValue of the correctGetters property.
1054 * @since 3.2
1055 */
1056 public boolean isCorrectGetters()
1057 {
1058 return correctGetters;
1059 }
1060
1061 /***
1062 * Set the correctGetters property of the column. If set to true, the
1063 * column returns is<xxx> as the getter name which is correct for the
1064 * Bean Specs but incompatible to pre-3.2 releases.
1065 *
1066 * @param correctGetters The new value of the correctGetters property.
1067 * @since 3.2
1068 */
1069 public void setCorrectGetters(boolean correctGetters)
1070 {
1071 this.correctGetters = correctGetters;
1072 }
1073 }