/**********************************************************************
Copyright (c) 2004 Erik Bengtson and others. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
Contributors:
2004 Andy Jefferson - localised messages
2004 Andy Jefferson - fixed getObject() to cater for decimal values
...
**********************************************************************/
package org.jpox.store.rdbms.mapping;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import org.jpox.ClassNameConstants;
import org.jpox.exceptions.JPOXDataStoreException;
import org.jpox.store.exceptions.NullValueException;
import org.jpox.store.mapped.DatastoreField;
import org.jpox.store.mapped.MappedStoreManager;
import org.jpox.store.mapped.expression.ScalarExpression;
import org.jpox.store.mapped.mapping.JavaTypeMapping;
import org.jpox.store.mapped.mapping.SingleFieldMapping;
import org.jpox.store.rdbms.Column;
import org.jpox.store.rdbms.adapter.RDBMSAdapter;
import org.jpox.store.rdbms.typeinfo.TypeInfo;
import org.jpox.util.StringUtils;
/**
* Mapping of a Big Integer RDBMS type.
*
* @version $Revision: 1.27 $
*/
public class BigIntRDBMSMapping extends ColumnMapping
{
/**
* @param storeMgr Store Manager
* @param mapping The java mapping
*/
protected BigIntRDBMSMapping(MappedStoreManager storeMgr, JavaTypeMapping mapping)
{
super(storeMgr, mapping);
}
/**
* Constructor.
* @param mapping Java type mapping
* @param storeMgr Store Manager
* @param field Field to be mapped
*/
public BigIntRDBMSMapping(JavaTypeMapping mapping, MappedStoreManager storeMgr, DatastoreField field)
{
super(storeMgr, mapping);
column = (Column) field;
initialize();
}
private void initialize()
{
if( column != null )
{
column.checkPrimitive();
// Valid Values
if (getJavaTypeMapping() instanceof SingleFieldMapping)
{
ScalarExpression[] validValues = ((SingleFieldMapping)getJavaTypeMapping()).getValidValues(0);
if (validValues != null)
{
String constraints = ((RDBMSAdapter)storeMgr.getDatastoreAdapter()).getCheckConstraintForValues(column.getIdentifier(), validValues, column.isNullable());
column.setConstraints(constraints);
}
}
}
initTypeInfo();
}
public TypeInfo getTypeInfo()
{
return getDatabaseAdapter().getTypeInfo(Types.BIGINT);
}
public void setInt(Object ps, int param, int value)
{
try
{
((PreparedStatement) ps).setLong(param, value);
}
catch (SQLException e)
{
throw new JPOXDataStoreException(LOCALISER.msg("055001", "int", "" + value), e);
}
}
public int getInt(Object rs, int param)
{
int value;
try
{
value = (int)((ResultSet) rs).getLong(param);
if( column == null || column.getColumnMetaData() == null || !column.getColumnMetaData().isAllowsNull() )
{
if (((ResultSet) rs).wasNull())
{
throw new NullValueException(LOCALISER.msg("055003",column));
}
}
}
catch (SQLException e)
{
throw new JPOXDataStoreException(LOCALISER.msg("055002", "int", "" + param, column, e.getMessage()), e);
}
return value;
}
public void setLong(Object ps, int param, long value)
{
try
{
((PreparedStatement) ps).setLong(param, value);
}
catch (SQLException e)
{
throw new JPOXDataStoreException(LOCALISER.msg("055001", "long", "" + value, column, e.getMessage()), e);
}
}
public long getLong(Object rs, int param)
{
long value;
try
{
value = ((ResultSet) rs).getLong(param);
if( column == null || column.getColumnMetaData() == null || !column.getColumnMetaData().isAllowsNull() )
{
if (((ResultSet) rs).wasNull())
{
throw new NullValueException(LOCALISER.msg("055003",column));
}
}
}
catch (SQLException e)
{
throw new JPOXDataStoreException(LOCALISER.msg("055002", "long", "" + param, column, e.getMessage()), e);
}
return value;
}
/**
* Setter for a parameter in a PreparedStatement
* @param ps The PreparedStatement
* @param param The parameter number to set
* @param value The value to set it to.
*/
public void setObject(Object ps, int param, Object value)
{
try
{
if (value == null)
{
if (column.isDefaultable() && column.getDefaultValue() != null &&
!StringUtils.isWhitespace(column.getDefaultValue().toString()))
{
((PreparedStatement) ps).setLong(param, Long.valueOf(column.getDefaultValue().toString().trim()).longValue());
}
else
{
((PreparedStatement) ps).setNull(param, getTypeInfo().dataType);
}
}
else
{
if (value instanceof java.util.Date)
{
((PreparedStatement) ps).setLong(param,((java.util.Date)value).getTime());
}
else
{
((PreparedStatement) ps).setLong(param, ((Number)value).longValue());
}
}
}
catch (SQLException e)
{
throw new JPOXDataStoreException(LOCALISER.msg("055001", "Long", "" + value, column, e.getMessage()), e);
}
}
/**
* Method to retrieve a Big int from a ResultSet.
* @param rs ResultSet
* @param param The Parameter number in the result set
* @return The BIGINT object
*/
public Object getObject(Object rs, int param)
{
Object value;
try
{
// Read the object as a String since that is the most DB independent
// type we can use and should always get us something.
String str = ((ResultSet) rs).getString(param);
if (((ResultSet)rs).wasNull())
{
value = null;
}
else
{
// Some RDBMS (e.g PostgreSQL) can return a long as a double
// so cater for this, and generate a Long :-)
try
{
// Try it as a long
value = new Long(str);
}
catch (NumberFormatException nfe)
{
// Must be a double precision, so cast it
value = new Long((new Double(str)).longValue());
}
if (getJavaTypeMapping().getJavaType().getName().equals(ClassNameConstants.JAVA_UTIL_DATE))
{
value = new java.util.Date(((Long)value).longValue());
}
}
}
catch (SQLException e)
{
String msg = LOCALISER.msg("055002", "Long", "" + param, column, e.getMessage());
throw new JPOXDataStoreException(msg, e);
}
return value;
}
}