Coverage report

  %line %branch
org.apache.torque.map.ColumnMap
31% 
95% 

 1  
 package org.apache.torque.map;
 2  
 
 3  
 /*
 4  
  * Licensed to the Apache Software Foundation (ASF) under one
 5  
  * or more contributor license agreements.  See the NOTICE file
 6  
  * distributed with this work for additional information
 7  
  * regarding copyright ownership.  The ASF licenses this file
 8  
  * to you under the Apache License, Version 2.0 (the
 9  
  * "License"); you may not use this file except in compliance
 10  
  * with the License.  You may obtain a copy of the License at
 11  
  *
 12  
  *   http://www.apache.org/licenses/LICENSE-2.0
 13  
  *
 14  
  * Unless required by applicable law or agreed to in writing,
 15  
  * software distributed under the License is distributed on an
 16  
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 17  
  * KIND, either express or implied.  See the License for the
 18  
  * specific language governing permissions and limitations
 19  
  * under the License.
 20  
  */
 21  
 
 22  
 import java.util.Collections;
 23  
 import java.util.Iterator;
 24  
 import java.util.Map;
 25  
 
 26  
 import org.apache.commons.collections.map.ListOrderedMap;
 27  
 
 28  
 /**
 29  
  * ColumnMap is used to model a column of a table in a database.
 30  
  * <p>
 31  
  * Note that this information should be set via the <Table>MapBuilder class and
 32  
  * not changed by applications. The set methods are only public because this
 33  
  * class needs them.
 34  
  *
 35  
  * @author <a href="mailto:jmcnally@collab.net">John D. McNally</a>
 36  
  * @author <a href="mailto:greg.monroe@dukece.com">Greg Monroe</a>
 37  
  * @version $Id: ColumnMap.java 473821 2006-11-11 22:37:25Z tv $
 38  
  */
 39  
 public class ColumnMap implements java.io.Serializable
 40  
 {
 41  
     /** The serialVersionUID for this class. */
 42  
     private static final long serialVersionUID = -5971184507395399165L;
 43  
 
 44  
     /** A sample object having the same java Type as the column. */
 45  96
     private Object type = null;
 46  
 
 47  
     /** The name of the Torque Type of the column. */
 48  96
     private String torqueType = null;
 49  
 
 50  
     /** Should object type be converted to primitive. */
 51  96
     private boolean usePrimitive = true;
 52  
 
 53  
     /** Size of the column. */
 54  96
     private int size = 0;
 55  
 
 56  
     /** Scale of the column */
 57  96
     private int scale = 0;
 58  
 
 59  
     /** Is it a primary key? */
 60  96
     private boolean pk = false;
 61  
 
 62  
     /** Is null value allowed ? */
 63  96
     private boolean notNull = false;
 64  
 
 65  
     /** Name of the table that this column is related to. */
 66  96
     private String relatedTableName = "";
 67  
 
 68  
     /** Name of the column that this column is related to. */
 69  96
     private String relatedColumnName = "";
 70  
 
 71  
     /** The TableMap for this column. */
 72  
     private TableMap table;
 73  
 
 74  
     /** The name of the column. */
 75  
     private String columnName;
 76  
 
 77  
     /**
 78  
      * The Java Name of this column as defined in XML or created by the
 79  
      * generator code.
 80  
      */
 81  
     private String javaName;
 82  
 
 83  
     /** Is this column an autoincrement column ? */
 84  96
     private boolean autoIncrement = false;
 85  
 
 86  
     /** Column description info (if any). */
 87  96
     private String description = "";
 88  
 
 89  
     /** is Column protected ? */
 90  96
     private boolean isProtected = false;
 91  
 
 92  
     /**
 93  
      * String representing the default value defined for field. Note that
 94  
      * default is a keyword, so defaultValue is used to store the value for the
 95  
      * get/setDefault() methods.
 96  
      */
 97  96
     private String defaultValue = null;
 98  
 
 99  
     /** Inheritance type used. */
 100  96
     private String inheritance = "false";
 101  
 
 102  
     /**
 103  
      * Does column uses Inheritance subclasses? Note that this is tied to the
 104  
      * TableMap useInheritance thru the set function.
 105  
      */
 106  
     private boolean useInheritance;
 107  
 
 108  
     /** Associated of inheritance maps. */
 109  96
     private Map inheritanceMaps = Collections
 110  
             .synchronizedMap(new ListOrderedMap());
 111  
 
 112  
     /** Input validator class name. (in DTD but not used?) */
 113  
     private String inputValidator;
 114  
 
 115  
     /** Java naming method the generator used. */
 116  
     private String javaNamingMethod;
 117  
 
 118  
     /** Java type string specified in XML. */
 119  
     private String javaType;
 120  
 
 121  
     /** Column position in the table (one based). */
 122  96
     private int position = -1;
 123  
 
 124  
     /**
 125  
      * Constructor.
 126  
      *
 127  
      * @param name The name of the column.
 128  
      * @param containingTable TableMap of the table this column is in.
 129  
      */
 130  
     public ColumnMap(String name, TableMap containingTable)
 131  96
     {
 132  96
         table = containingTable;
 133  96
         this.columnName = normalizeName(name);
 134  96
     }
 135  
 
 136  
     /**
 137  
      * Makes sure that the column names don't include table prefixes. E.g.,
 138  
      * SCARAB_PROJECT.PROJECT_ID should be PROJECT_ID.
 139  
      *
 140  
      * @param name The name to check
 141  
      * @return The corrected name if needed or the same name if not.
 142  
      */
 143  
     protected String normalizeName(String name)
 144  
     {
 145  96
         if (name.indexOf('.') > 0)
 146  
         {
 147  0
             return name.substring(name.lastIndexOf('.') + 1);
 148  
         }
 149  96
         return name;
 150  
     }
 151  
 
 152  
     /**
 153  
      * Get the name of a column.
 154  
      *
 155  
      * @return A String with the column name.
 156  
      */
 157  
     public String getColumnName()
 158  
     {
 159  32
         return columnName;
 160  
     }
 161  
 
 162  
     /**
 163  
      * Get the table name + column name.
 164  
      *
 165  
      * @return A String with the full column name.
 166  
      */
 167  
     public String getFullyQualifiedName()
 168  
     {
 169  0
         return table.getName() + "." + columnName;
 170  
     }
 171  
 
 172  
     /**
 173  
      * Get the name of the table this column is in.
 174  
      *
 175  
      * @return A String with the table name.
 176  
      */
 177  
     public String getTableName()
 178  
     {
 179  0
         return table.getName();
 180  
     }
 181  
 
 182  
     /**
 183  
      * Set the type of this column.
 184  
      *
 185  
      * @param type An Object specifying the type.
 186  
      */
 187  
     public void setType(Object type)
 188  
     {
 189  96
         this.type = type;
 190  96
     }
 191  
 
 192  
     /**
 193  
      * Set the Torque type of this column.
 194  
      *
 195  
      * @param torqueType the Torque type of the column.
 196  
      */
 197  
     public void setTorqueType(String torqueType)
 198  
     {
 199  0
         this.torqueType = torqueType;
 200  0
     }
 201  
 
 202  
     /**
 203  
      * Set the size of this column.
 204  
      *
 205  
      * @param size An int specifying the size.
 206  
      */
 207  
     public void setSize(int size)
 208  
     {
 209  64
         this.size = size;
 210  64
     }
 211  
 
 212  
     /**
 213  
      * Set if this column is a primary key or not.
 214  
      *
 215  
      * @param pk True if column is a primary key.
 216  
      */
 217  
     public void setPrimaryKey(boolean pk)
 218  
     {
 219  64
         this.pk = pk;
 220  64
     }
 221  
 
 222  
     /**
 223  
      * Set if this column may be null.
 224  
      *
 225  
      * @param nn True if column may be null.
 226  
      */
 227  
     public void setNotNull(boolean nn)
 228  
     {
 229  0
         this.notNull = nn;
 230  0
     }
 231  
 
 232  
     /**
 233  
      * Set the foreign key for this column.
 234  
      *
 235  
      * @param fullyQualifiedName The name of the table.column that is
 236  
      * foreign.
 237  
      */
 238  
     public void setForeignKey(String fullyQualifiedName)
 239  
     {
 240  0
         if (fullyQualclass="keyword">ifiedName != null && fullyQualclass="keyword">ifiedName.length() > 0)
 241  
         {
 242  0
             relatedTableName = fullyQualifiedName.substring(
 243  
                     0, fullyQualifiedName.indexOf('.'));
 244  0
             relatedColumnName = fullyQualifiedName.substring(
 245  
                     fullyQualifiedName.indexOf('.') + 1);
 246  0
         }
 247  
         else
 248  
         {
 249  0
             relatedTableName = "";
 250  0
             relatedColumnName = "";
 251  
         }
 252  0
     }
 253  
 
 254  
     /**
 255  
      * Set the foreign key for this column.
 256  
      *
 257  
      * @param tableName The name of the table that is foreign.
 258  
      * @param columnName The name of the column that is foreign.
 259  
      */
 260  
     public void setForeignKey(String tableName, String columnName)
 261  
     {
 262  64
         if (tableName != null && tableName.length() > 0 && columnName != class="keyword">null
 263  
                 && columnName.length() > 0)
 264  
         {
 265  0
             relatedTableName = tableName;
 266  0
             relatedColumnName = normalizeName(columnName);
 267  0
         }
 268  
         else
 269  
         {
 270  64
             relatedTableName = "";
 271  64
             relatedColumnName = "";
 272  
         }
 273  64
     }
 274  
 
 275  
     /**
 276  
      * Get the type of this column. Note that if usePrimitive is true, this may
 277  
      * need to be converted.
 278  
      *
 279  
      * @return An Object specifying the type.
 280  
      */
 281  
     public Object getType()
 282  
     {
 283  16
         return type;
 284  
     }
 285  
 
 286  
     /**
 287  
      * Get the name of the Torque type of this column.
 288  
      *
 289  
      * @return The name of the Torque type of this column.
 290  
      */
 291  
     public String getTorqueType()
 292  
     {
 293  0
         return torqueType;
 294  
     }
 295  
 
 296  
     /**
 297  
      * The "precision" value from the XML
 298  
      * size="&lt;precision&gt;[,&lt;scale&gt;]"
 299  
      * attribute. Where [,&lt;scale&gt;] is optional.
 300  
      *
 301  
      * If the size attribute has not been set in the XML, it will return 0.
 302  
      * <p>
 303  
      *
 304  
      * Note that the size="P,S" format should be replaced with size="P"
 305  
      * scale="S".
 306  
      *
 307  
      * @return An int specifying the size.
 308  
      */
 309  
     public int getSize()
 310  
     {
 311  0
         return size;
 312  
     }
 313  
 
 314  
     /**
 315  
      * Is this column a primary key?
 316  
      *
 317  
      * @return True if column is a primary key.
 318  
      */
 319  
     public boolean isPrimaryKey()
 320  
     {
 321  0
         return pk;
 322  
     }
 323  
 
 324  
     /**
 325  
      * Is null value allowed ?
 326  
      *
 327  
      * @return True if column may be null.
 328  
      */
 329  
     public boolean isNotNull()
 330  
     {
 331  0
         return (notNull || isPrimaryKey());
 332  
     }
 333  
 
 334  
     /**
 335  
      * Is this column a foreign key?
 336  
      *
 337  
      * @return True if column is a foreign key.
 338  
      */
 339  
     public boolean isForeignKey()
 340  
     {
 341  0
         return (relatedTableName != null && relatedTableName.length() > 0);
 342  
     }
 343  
 
 344  
     /**
 345  
      * Get the table.column that this column is related to.
 346  
      *
 347  
      * @return A String with the full name for the related column.
 348  
      */
 349  
     public String getRelatedName()
 350  
     {
 351  0
         return relatedTableName + "." + relatedColumnName;
 352  
     }
 353  
 
 354  
     /**
 355  
      * Get the table name that this column is related to.
 356  
      *
 357  
      * @return A String with the name for the related table.
 358  
      */
 359  
     public String getRelatedTableName()
 360  
     {
 361  0
         return relatedTableName;
 362  
     }
 363  
 
 364  
     /**
 365  
      * Get the column name that this column is related to.
 366  
      *
 367  
      * @return A String with the name for the related column.
 368  
      */
 369  
     public String getRelatedColumnName()
 370  
     {
 371  0
         return relatedColumnName;
 372  
     }
 373  
 
 374  
     /**
 375  
      * Gets the scale set for this column (if any) as set in the XML database
 376  
      * definition. E.g., the value of the scale attribute or the scale portion
 377  
      * of a size="P,S" attribute. (Note: size="P,S" format is being
 378  
      * deprecated!).
 379  
      *
 380  
      * @return Returns the scale.
 381  
      */
 382  
     public int getScale()
 383  
     {
 384  0
         return scale;
 385  
     }
 386  
 
 387  
     /**
 388  
      * @param scale The scale to set.
 389  
      */
 390  
     public void setScale(int scale)
 391  
     {
 392  64
         this.scale = scale;
 393  64
     }
 394  
 
 395  
     /**
 396  
      * Gets the Java Name for this column as defined in XML or created by
 397  
      * generator code.
 398  
      *
 399  
      * @return the Java Name.
 400  
      */
 401  
     public String getJavaName()
 402  
     {
 403  0
         return this.javaName;
 404  
     }
 405  
 
 406  
     /**
 407  
      * Sets the Java Name for this column.
 408  
      *
 409  
      * @param name the Java Name.
 410  
      */
 411  
     public void setJavaName(String name)
 412  
     {
 413  0
         this.javaName = name;
 414  0
     }
 415  
 
 416  
     /**
 417  
      * Returns whether this column is an autoincrement column.
 418  
      *
 419  
      * @return true if this column is an autoIncrement column, false otherwise.
 420  
      */
 421  
     public boolean isAutoIncrement()
 422  
     {
 423  0
         return autoIncrement;
 424  
     }
 425  
 
 426  
     /**
 427  
      * Sets whether this column is an autoincrement column.
 428  
      *
 429  
      * @param autoIncrement whether this colimn is an autoincrement column.
 430  
      */
 431  
     public void setAutoIncrement(boolean autoIncrement)
 432  
     {
 433  0
         this.autoIncrement = autoIncrement;
 434  0
     }
 435  
 
 436  
     /**
 437  
      * A string representing the default value defined for this column.
 438  
      *
 439  
      * @return The default value of this column, if any.
 440  
      */
 441  
     public String getDefault()
 442  
     {
 443  0
         return defaultValue;
 444  
     }
 445  
 
 446  
     /**
 447  
      * Sets the default value for this column.
 448  
      *
 449  
      * @param defaultValue The defaultValue to set.
 450  
      */
 451  
     public void setDefault(String defaultValue)
 452  
     {
 453  0
         this.defaultValue = defaultValue;
 454  0
     }
 455  
 
 456  
     /**
 457  
      * Returns the column description info.
 458  
      *
 459  
      * @return the description, if any.
 460  
      */
 461  
     public String getDescription()
 462  
     {
 463  0
         return description;
 464  
     }
 465  
 
 466  
     /**
 467  
      * Sets the description for this column.
 468  
      *
 469  
      * @param description The description to set.
 470  
      */
 471  
     public void setDescription(String description)
 472  
     {
 473  0
         this.description = description;
 474  0
     }
 475  
 
 476  
     /**
 477  
      * Get the inheritance information associated with this column,
 478  
      *
 479  
      * @return Returns an array of associated inheritanceMap.
 480  
      *         The array is in XML order.
 481  
      */
 482  
     public InheritanceMap[] getInheritanceMaps()
 483  
     {
 484  0
         InheritanceMap[] iMaps = new InheritanceMap[inheritanceMaps.size()];
 485  0
         synchronized (inheritanceMaps)
 486  
         {
 487  0
             Iterator it = inheritanceMaps.values().iterator();
 488  0
             int i = 0;
 489  0
             while (it.hasNext())
 490  
             {
 491  0
                 iMaps[i++] = (InheritanceMap) it.next();
 492  0
             }
 493  0
         }
 494  0
         return iMaps;
 495  
     }
 496  
 
 497  
     /**
 498  
      * Add an associated inheritance mapping.
 499  
      *
 500  
      * @param map The inheritanceMap to associate with this column.
 501  
      */
 502  
     public void addInheritanceMap(InheritanceMap map)
 503  
     {
 504  0
         setUseInheritance(true);
 505  0
         this.inheritanceMaps.put(map.getKey(), map);
 506  0
     }
 507  
 
 508  
     /**
 509  
      * Gets the inheritance type used.
 510  
      *
 511  
      * @return the inheritance type used.
 512  
      */
 513  
     public String getInheritance()
 514  
     {
 515  0
         return inheritance;
 516  
     }
 517  
 
 518  
     /**
 519  
      * Sets the inheritance type.
 520  
      *
 521  
      * @param inheritanceType The inheritance type to set.
 522  
      */
 523  
     public void setInheritance(String inheritanceType)
 524  
     {
 525  0
         this.inheritance = inheritanceType;
 526  0
     }
 527  
 
 528  
     /**
 529  
      * Returns the input validator class name.
 530  
      * (This property is in the DTD, but currently not used by Torque?)
 531  
      *
 532  
      * @return Returns the inputValidator.
 533  
      */
 534  
     public String getInputValidator()
 535  
     {
 536  0
         return inputValidator;
 537  
     }
 538  
 
 539  
     /**
 540  
      * Sets the input validator class name.
 541  
      *
 542  
      * @param inputValidator The inputValidator to set.
 543  
      */
 544  
     public void setInputValidator(String inputValidator)
 545  
     {
 546  0
         this.inputValidator = inputValidator;
 547  0
     }
 548  
 
 549  
     /**
 550  
      * Returns whether getters and setters are generated with the
 551  
      * access modifier "protected" rather than "public".
 552  
      *
 553  
      * @return whether the accessors should be protected rather than public.
 554  
      */
 555  
     public boolean isProtected()
 556  
     {
 557  0
         return isProtected;
 558  
     }
 559  
 
 560  
     /**
 561  
      * Sets whether getters and setters should be generated with the
 562  
      * access modifier "protected" rather than "public".
 563  
      *
 564  
      * @param isProtected whether getters and setters for this column
 565  
      *        are protected.
 566  
      */
 567  
     public void setProtected(boolean isProtected)
 568  
     {
 569  0
         this.isProtected = isProtected;
 570  0
     }
 571  
 
 572  
     /**
 573  
      * Returns whether this column is a primary key.
 574  
      *
 575  
      * @return whether this column is a primary key.
 576  
      */
 577  
     public boolean isPk()
 578  
     {
 579  0
         return pk;
 580  
     }
 581  
 
 582  
     /**
 583  
      * Sets whether this column is a primary key.
 584  
      *
 585  
      * @param pk whether this column is a primary key.
 586  
      */
 587  
     public void setPk(boolean pk)
 588  
     {
 589  0
         this.pk = pk;
 590  0
     }
 591  
 
 592  
     /**
 593  
      * Returns whether this column uses inheritance subclasses.
 594  
      *
 595  
      * @return true if inheritance subclasses are used, false otherwise.
 596  
      */
 597  
     public boolean isUseInheritance()
 598  
     {
 599  0
         return useInheritance;
 600  
     }
 601  
 
 602  
     /**
 603  
      * Sets whether this column uses inheritance subclasses.
 604  
      *
 605  
      * @param useInheritance whether this column uses Inheritance subclasses.
 606  
      */
 607  
     public void setUseInheritance(boolean useInheritance)
 608  
     {
 609  0
         this.useInheritance = useInheritance;
 610  0
     }
 611  
 
 612  
     /**
 613  
      * Get the inheritance map with the specified key.
 614  
      *
 615  
      * @param key the key of the inheritance map.
 616  
      * @return the inheritance map with the specified key, or null if no
 617  
      *         inheritance map with the specified key exists in this column.
 618  
      */
 619  
     public InheritanceMap getInheritanceMap(String key)
 620  
     {
 621  0
         return (InheritanceMap) inheritanceMaps.get(key);
 622  
     }
 623  
 
 624  
     /**
 625  
      * Returns whether this colum uses primitive values rather than objects.
 626  
      *
 627  
      * @return true if this colum uses primitive values, false if it uses
 628  
      *         objects.
 629  
      */
 630  
     public boolean isUsePrimitive()
 631  
     {
 632  0
         return usePrimitive;
 633  
     }
 634  
 
 635  
     /**
 636  
      * Sets whether this colum uses primitive values rather than objects.
 637  
      *
 638  
      * @param usePrimitive whether primitive objects are used
 639  
      *        rather than objects.
 640  
      */
 641  
     public void setUsePrimitive(boolean usePrimitive)
 642  
     {
 643  0
         this.usePrimitive = usePrimitive;
 644  0
     }
 645  
 
 646  
     /**
 647  
      * Returns the Java naming method for this column.
 648  
      *
 649  
      * @return the javaNamingMethod for this column.
 650  
      */
 651  
     public String getJavaNamingMethod()
 652  
     {
 653  0
         return javaNamingMethod;
 654  
     }
 655  
 
 656  
     /**
 657  
      * Sets the java naming method for this column.
 658  
      *
 659  
      * @param javaNamingMethod The javaNamingMethod to set.
 660  
      */
 661  
     public void setJavaNamingMethod(String javaNamingMethod)
 662  
     {
 663  0
         this.javaNamingMethod = javaNamingMethod;
 664  0
     }
 665  
 
 666  
     /**
 667  
      * Returns the map for the table this column belongs to.
 668  
      *
 669  
      * @return the table map for this column.
 670  
      */
 671  
     public TableMap getTable()
 672  
     {
 673  0
         return table;
 674  
     }
 675  
 
 676  
     /**
 677  
      * Returns the position (one based) of this column in the table.
 678  
      * XML order is preserved.
 679  
      *
 680  
      * @return The position of this column, one-based.
 681  
      */
 682  
     public int getPosition()
 683  
     {
 684  0
         return position;
 685  
     }
 686  
 
 687  
     /**
 688  
      * Sets the position (one based) of this column in the table.
 689  
      *
 690  
      * @param position The position to set.
 691  
      */
 692  
     public void setPosition(int position)
 693  
     {
 694  0
         this.position = position;
 695  0
     }
 696  
 
 697  
     /**
 698  
      * Returns the java type of this column.
 699  
      *
 700  
      * @return the javaType.
 701  
      */
 702  
     public String getJavaType()
 703  
     {
 704  0
         return javaType;
 705  
     }
 706  
 
 707  
     /**
 708  
      * Sets the java type of this column.
 709  
      *
 710  
      * @param javaType The javaType to set.
 711  
      */
 712  
     public void setJavaType(String javaType)
 713  
     {
 714  0
         this.javaType = javaType;
 715  0
     }
 716  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.