Coverage Report

Coverage Report - org.melati.poem.BigDecimalPoemType

Classes in this File

Line Coverage

Branch Coverage

Complexity

BigDecimalPoemType

100%

25/25

80%

8/10

2.1

 /*
  * $Source$
  * $Revision$
  *
  * Copyright (C) 2003 Samuel Goldstein
  *
  * Part of Melati (http://melati.org), a framework for the rapid
  * development of clean, maintainable web applications.
  *
  * Melati is free software; Permission is granted to copy, distribute
  * and/or modify this software under the terms either:
  *
  * a) the GNU General Public License as published by the Free Software
  *    Foundation; either version 2 of the License, or (at your option)
  *    any later version,
  *
  *    or
  *
  * b) any version of the Melati Software License, as published
  *    at http://melati.org
  *
  * You should have received a copy of the GNU General Public License and
  * the Melati Software License along with this program;
  * if not, write to the Free Software Foundation, Inc.,
  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the
  * GNU General Public License and visit http://melati.org to obtain the
  * Melati Software License.
  *
  * Feel free to contact the Developers of Melati (http://melati.org),
  * if you would like to work out a different arrangement than the options
  * outlined here.  It is our intention to allow Melati to be used by as
  * wide an audience as possible.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * Contact details for copyright holder:
  *
  *     Samuel Goldstein <samuel At 1969.ws>
  *     http://www.1969.ws
  *     13101 W. Washington Blvd Suite 248, Los Angeles, CA 90066 USA
  */
 
 package org.melati.poem;
 
 import java.sql.Types;
 import java.sql.ResultSet;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
 import java.math.BigDecimal;
 import org.melati.poem.dbms.Dbms;
 
 /**
  * Java "BigDecimal", dependant upon the database/SQL implementation.
  *
  * By default, this is a 22 digit number, with 2 digits after the
  * decimal.
  * */
 public class BigDecimalPoemType extends FixedPointAtomPoemType<BigDecimal> {
 
   /**
    * Constructor.
    * 
    * @param nullable whether nullable 
    */
   public BigDecimalPoemType(boolean nullable) {
     super(Types.DECIMAL, "DECIMAL", nullable, 22, 2);
   }
 
   /**
    * Constructor.
    * 
    * @param nullable whether nullable 
    * @param precision defaults to 22
    * @param scale defaults to 2
    */
   public BigDecimalPoemType(boolean nullable, int precision, int scale) {
     super(Types.DECIMAL, "DECIMAL", nullable, precision, scale);
     // because a newly added column of this type won't have valid 
     // numbers, we fix that here...
     // This does not appear to be needed - timp 01/01/2006
     /* 
     if (precision <= 0) {
       setPrecision(22);
     }
     if (scale < 0) {
       setScale(2);
     }
     */
   }
 
   protected void _assertValidRaw(Object raw) {
     if (raw != null && !(raw instanceof BigDecimal))
       throw new TypeMismatchPoemException(raw, this);
   }
 
   protected BigDecimal _getRaw(ResultSet rs, int col) throws SQLException {
     synchronized (rs) {
       BigDecimal x = rs.getBigDecimal(col);
       return rs.wasNull() ? null : x; }
   }
 
   protected void _setRaw(PreparedStatement ps, int col, Object real)
     throws SQLException {
     ps.setBigDecimal(col, ((BigDecimal)real));
   }
 
   protected BigDecimal _rawOfString(String rawString) throws ParsingPoemException {
     try {
       return new BigDecimal(rawString);
     } catch (NumberFormatException e) {
       throw new ParsingPoemException(this, rawString, e);
     }
   }
 
   protected String _sqlDefinition(Dbms dbms) {
     try {
       return dbms.getFixedPtSqlDefinition(getScale(), getPrecision());
     } catch (SQLException e) {
       throw new SQLSeriousPoemException(e);
     }
   }
 
   /**
    * Whilst BigDecimal cannot represent all Doubles it can represent 
    * legacy money doubles, so we allow it to enable upgrades from Doubles 
    * to BigDecimals.
    * @see org.melati.poem.BasePoemType#_canRepresent(org.melati.poem.SQLPoemType)
    */
   protected boolean _canRepresent(SQLPoemType<?> other) {
     return // sqlTypeCode() == other.sqlTypeCode() && //commented out to allow doubles  
            other instanceof BigDecimalPoemType || other instanceof DoublePoemType;
   }
 
   /**
    * @return the field type used in the Data Structure Definition language.
    */
   public String toDsdType() {
     return "BigDecimal";
   }
 
   protected void _saveColumnInfo(ColumnInfo columnInfo)
     throws AccessPoemException {
     columnInfo.setTypefactory(PoemTypeFactory.BIGDECIMAL);
     columnInfo.setPrecision(getPrecision());
     columnInfo.setScale(getScale());
   }
 
 }

1		/*
2		* $Source$
3		* $Revision$
4		*
5		* Copyright (C) 2003 Samuel Goldstein
6		*
7		* Part of Melati (http://melati.org), a framework for the rapid
8		* development of clean, maintainable web applications.
9		*
10		* Melati is free software; Permission is granted to copy, distribute
11		* and/or modify this software under the terms either:
12		*
13		* a) the GNU General Public License as published by the Free Software
14		* Foundation; either version 2 of the License, or (at your option)
15		* any later version,
16		*
17		* or
18		*
19		* b) any version of the Melati Software License, as published
20		* at http://melati.org
21		*
22		* You should have received a copy of the GNU General Public License and
23		* the Melati Software License along with this program;
24		* if not, write to the Free Software Foundation, Inc.,
25		* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA to obtain the
26		* GNU General Public License and visit http://melati.org to obtain the
27		* Melati Software License.
28		*
29		* Feel free to contact the Developers of Melati (http://melati.org),
30		* if you would like to work out a different arrangement than the options
31		* outlined here. It is our intention to allow Melati to be used by as
32		* wide an audience as possible.
33		*
34		* This program is distributed in the hope that it will be useful,
35		* but WITHOUT ANY WARRANTY; without even the implied warranty of
36		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
37		* GNU General Public License for more details.
38		*
39		* Contact details for copyright holder:
40		*
41		* Samuel Goldstein <samuel At 1969.ws>
42		* http://www.1969.ws
43		* 13101 W. Washington Blvd Suite 248, Los Angeles, CA 90066 USA
44		*/
45
46		package org.melati.poem;
47
48		import java.sql.Types;
49		import java.sql.ResultSet;
50		import java.sql.PreparedStatement;
51		import java.sql.SQLException;
52		import java.math.BigDecimal;
53		import org.melati.poem.dbms.Dbms;
54
55		/**
56		* Java "BigDecimal", dependant upon the database/SQL implementation.
57		*
58		* By default, this is a 22 digit number, with 2 digits after the
59		* decimal.
60		* */
61	20	public class BigDecimalPoemType extends FixedPointAtomPoemType<BigDecimal> {
62
63		/**
64		* Constructor.
65		*
66		* @param nullable whether nullable
67		*/
68		public BigDecimalPoemType(boolean nullable) {
69	108	super(Types.DECIMAL, "DECIMAL", nullable, 22, 2);
70	108	}
71
72		/**
73		* Constructor.
74		*
75		* @param nullable whether nullable
76		* @param precision defaults to 22
77		* @param scale defaults to 2
78		*/
79		public BigDecimalPoemType(boolean nullable, int precision, int scale) {
80	294	super(Types.DECIMAL, "DECIMAL", nullable, precision, scale);
81		// because a newly added column of this type won't have valid
82		// numbers, we fix that here...
83		// This does not appear to be needed - timp 01/01/2006
84		/*
85		if (precision <= 0) {
86		setPrecision(22);
87		}
88		if (scale < 0) {
89		setScale(2);
90		}
91		*/
92	294	}
93
94		protected void _assertValidRaw(Object raw) {
95	40	if (raw != null && !(raw instanceof BigDecimal))
96	8	throw new TypeMismatchPoemException(raw, this);
97	32	}
98
99		protected BigDecimal _getRaw(ResultSet rs, int col) throws SQLException {
100	6	synchronized (rs) {
101	2	BigDecimal x = rs.getBigDecimal(col);
102	2	return rs.wasNull() ? null : x; }
103		}
104
105		protected void _setRaw(PreparedStatement ps, int col, Object real)
106		throws SQLException {
107	6	ps.setBigDecimal(col, ((BigDecimal)real));
108	2	}
109
110		protected BigDecimal _rawOfString(String rawString) throws ParsingPoemException {
111		try {
112	14	return new BigDecimal(rawString);
113	2	} catch (NumberFormatException e) {
114	2	throw new ParsingPoemException(this, rawString, e);
115		}
116		}
117
118		protected String _sqlDefinition(Dbms dbms) {
119		try {
120	13	return dbms.getFixedPtSqlDefinition(getScale(), getPrecision());
121	2	} catch (SQLException e) {
122	2	throw new SQLSeriousPoemException(e);
123		}
124		}
125
126		/**
127		* Whilst BigDecimal cannot represent all Doubles it can represent
128		* legacy money doubles, so we allow it to enable upgrades from Doubles
129		* to BigDecimals.
130		* @see org.melati.poem.BasePoemType#_canRepresent(org.melati.poem.SQLPoemType)
131		*/
132		protected boolean _canRepresent(SQLPoemType<?> other) {
133	144	return // sqlTypeCode() == other.sqlTypeCode() && //commented out to allow doubles
134		other instanceof BigDecimalPoemType \|\| other instanceof DoublePoemType;
135		}
136
137		/**
138		* @return the field type used in the Data Structure Definition language.
139		*/
140		public String toDsdType() {
141	4	return "BigDecimal";
142		}
143
144		protected void _saveColumnInfo(ColumnInfo columnInfo)
145		throws AccessPoemException {
146	126	columnInfo.setTypefactory(PoemTypeFactory.BIGDECIMAL);
147	126	columnInfo.setPrecision(getPrecision());
148	126	columnInfo.setScale(getScale());
149	126	}
150
151		}