Attachment #138796 for bug #178897

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 178897
Collapse All | Expand All




 *
 * Contributors:
 *  Actuate Corporation  - initial API and implementation
 *
 *************************************************************************
 */
package org.eclipse.birt.core.data;

import java.math.BigDecimal;

	public static final int UNKNOWN_TYPE = -1;
	public static final int ANY_TYPE = 0;
	public static final int BOOLEAN_TYPE = 1;
	public static final int INTEGER_TYPE = 2;
	public static final int DOUBLE_TYPE = 3;
	public static final int DECIMAL_TYPE = 4;
	public static final int STRING_TYPE = 5;
	public static final int DATE_TYPE = 6;
	public static final int BLOB_TYPE = 7;
	public static final int BINARY_TYPE = 8;
	public static final int SQL_DATE_TYPE = 9;
	public static final int SQL_TIME_TYPE = 10;
	public static final int OBJECT_TYPE = 11;

	private static final String[] names =
	{
			"Any",
			"Boolean",
			"Integer",

			"Blob",
			"Binary",
			"Date",
			"Time",
			"Java Object"
	};

	public static final String ANY_TYPE_NAME = names[0];
	public static final String BOOLEAN_TYPE_NAME = names[1];
	public static final String INTEGER_TYPE_NAME = names[2];

	public static final String BINARY_TYPE_NAME = names[8];
	public static final String SQL_DATE_TYPE_NAME = names[9];
	public static final String SQL_TIME_TYPE_NAME = names[10];
	public static final String JAVA_OBJECT_TYPE_NAME = names[11];

	private static final Class[] classes =
	{
			AnyType.class,
			Boolean.class,
			Integer.class,

			byte[].class,
			java.sql.Date.class,
			java.sql.Time.class,
			Object.class
	};

	/**
	 * Gets the description of a data type.
	 * @param typeCode Data type enumeration value

	        return new String( "Unknown" );
		}
		return names[typeCode];
	}

	/**
	 * Gets the Java class used to represent the specified data type.
	 * @return Class for the specified data type. If data type is unknown or ANY, returns null.
	 */
	public static Class getClass( int typeCode )
	{

		}
		return classes[typeCode];
	}

	/**
	 *
	 * @param objClass
	 * @return
	 */

		}
		return false;
	}

	/**
	 * Other type can be found in JDK, such as Integer and String, but AnyType
	 * have to be manually created to make it correspond to "Any" name.
	 */
	public static final class AnyType
	{
	};

}




	// we will try to parse it for Locale.US
	private static ULocale DEFAULT_LOCALE = ULocale.US;
	private static ULocale JRE_DEFAULT_LOCALE = ULocale.getDefault( );

	// cache DateFormatter of ICU
	private static Map dfMap = new HashMap( );
	private static Map nfMap = new HashMap( );
	// Default Date/Time Style
	private static int DEFAULT_DATE_STYLE = DateFormat.FULL;

	// resource bundle for exception messages
	public static ResourceBundle resourceBundle = ( new ResourceHandle( JRE_DEFAULT_LOCALE ) ).getUResourceBundle( );

	public static long count = 0;

	/**
	 * convert an object to given type
	 * Types supported:

	 * 		DataType.BLOB_TYPE
	 *		DataType.SQL_DATE_TYPE
	 *		DataType.SQL_TIME_TYPE
	 *      DataType.OBJECT_TYPE
	 * @param source
	 * @param toType
	 * @return

			throws BirtException
	{
		source = JavascriptEvalUtil.convertJavascriptValue( source );

		// here we assume the efficiency of if else is higher than switch case
		if ( toType == DataType.UNKNOWN_TYPE || toType == DataType.ANY_TYPE )
			return source;

			case DataType.STRING_TYPE :
				return toString( source );
			case DataType.BLOB_TYPE :
				 return toBytes( source );
			case DataType.BINARY_TYPE :
				return toBytes( source );
			case DataType.SQL_DATE_TYPE:
				return toSqlDate( source );
			case DataType.SQL_TIME_TYPE:
				return toSqlTime( source );
			case DataType.OBJECT_TYPE:
			    return source;
			default :
				throw new CoreException( ResourceConstants.INVALID_TYPE,
						resourceBundle );

		{
			return source;
		}

		if ( toTypeClass == DataType.getClass( DataType.ANY_TYPE ) )
			return source;
		if ( toTypeClass == Integer.class )

            return toSqlTime( source );
        if ( toTypeClass == java.sql.Date.class)
           	return toSqlDate( source );
        if ( toTypeClass == java.sql.Timestamp.class )
			return toTimestamp( source );
		if ( toTypeClass == Date.class )
			return toDate( source );
		if ( toTypeClass == Double.class )
			return toDouble( source );

			if ( source instanceof byte[] )
				return source;
			else
				return toBlob( source );
		}
		if ( toTypeClass == byte[].class ||
		     toTypeClass == Object.class )
			return source;

		throw new CoreException( ResourceConstants.INVALID_TYPE,

	/**
	 * Boolean -> Integer
	 * 		true 	-> 1
	 * 		others 	-> 0
	 * Date -> Integer
	 * 		Date.getTime();
	 * String -> Integer

		}
		else if ( source instanceof Number )
		{
			// This takes care of BigDecimal, BigInteger, Byte, Double,
			// Float, Long, Short
			if ( !isConvertableToInteger( (Number) source ) )
			{

						}
						return new Integer( number.intValue( ));
					}

					throw new CoreException( ResourceConstants.CONVERT_FAILS,
							new Object[]{
									source.toString( ), "Integer"

	/**
	 * Boolean -> BigDecimal
	 * 		true 	-> 1
	 * 		others 	-> 0
	 * Date -> BigDecimal
	 * 		Date.getTime();
	 * String -> BigDecimal

		}
		else if ( source instanceof Number )
		{
			// This takes care of BigDecimal, BigInteger, Byte, Double,
			// Float, Long, Short, Integer
			// An intermediate conversion using String is preferrable per JavaDoc
			// comment in BigDecimal(String) constructor

			}
			catch ( NumberFormatException e )
			{
				throw new CoreException(
						ResourceConstants.CONVERT_FAILS,
						new Object[]{
								str, "BigDecimal"

							.parse( (String) source );
					if( number != null )
						return new BigDecimal( number.toString( ) );

					throw new CoreException( ResourceConstants.CONVERT_FAILS,
							new Object[]{
									source.toString( ), "BigDecimal"

		}
		else
		{
			throw new CoreException(
					ResourceConstants.CONVERT_FAILS,
					new Object[]{
							source.toString( ), "Boolean"

	 * Number -> Date
	 * 		new Date((long)Number)
	 * String -> Date
	 * 		toDate(String)
	 * @param source
	 * @return
	 * @throws BirtException

					});
		}
	}

	/**
	 *
	 * @param source
	 * @return
	 * @throws BirtException

			return null;
		return new Timestamp( date.getTime( ));
	}

    /**
     * Date -> Time
     * String -> Time

                }
                catch ( Exception e1 )
                {

                }
            }
        }

    }

    /**
     *
     * @param value
     * @return
     */

		int firstColon;
		int secondColon;
		int marker;

		if ( s == null )
			throw new java.lang.IllegalArgumentException( );


			second = Integer.parseInt( s.substring( secondColon + 1 ) );
		if( second < 0 || second > 60 )
			throw new java.lang.IllegalArgumentException( );

		return toSqlTime( hour, minute, second );
	}

    /**
     *
     * @param hour
     * @param minute
     * @param second

		calendar.set( Calendar.SECOND, second );
		return new java.sql.Time( calendar.getTimeInMillis( ) );
    }

    /**
     *
     * @param c
     * @return
     */

			return true;
		return false;
	}

    /**
	 *
	 * @param date
	 * @return
	 */

		calendar.set( Calendar.DAY_OF_MONTH, 1 );
		return new java.sql.Time( calendar.getTimeInMillis( ) );
    }

    /**
     * Date -> Time
     * String -> Time

                }
                catch ( Exception e1 )
                {

                }
            }
        }

                            source.toString( ), "java.sql.Date"
                    } );
    }

    /**
     *
     * @param date
     * @return
     */

		calendar.set( Calendar.HOUR_OF_DAY, 0 );
		calendar.set( Calendar.MINUTE, 0 );
		calendar.set( Calendar.SECOND, 0 );
		calendar.set( Calendar.MILLISECOND, 0 );
		return new java.sql.Date( calendar.getTimeInMillis( ) );
    }

    /**
	 * A temp solution to the adoption of ICU4J to BIRT. Simply delegate
	 * toDate( String, Locale) method.
	 *
	 * @param source
	 *            the String to be convert
	 * @param locate


	/**
	 * convert String with the specified locale to java.util.Date
	 *
	 * @param source
	 *            the String to be convert
	 * @param locate

	{
		return toDate( source, locale, null );
	}

	/**
	 *
	 * @param source
	 * @param locale
	 * @param timeZone


		DateFormat dateFormat = null;
		Date resultDate = null;

		boolean existTime = source.matches( ".*[0-9]+:[0-9]+:[0-9]+.*" )
				|| source.matches( ".*[0-9]+:[0-9]+.*" );


			for ( int j = DEFAULT_DATE_STYLE; j <= DateFormat.SHORT; j++ )
			{
				dateFormat = DateFormatFactory.getDateTimeInstance( i, j, locale );
				TimeZone savedTimeZone = null;
				if( timeZone != null )
				{
					savedTimeZone = dateFormat.getTimeZone( );

				catch ( ParseException e1 )
				{
				}
				finally
				{
					if( savedTimeZone != null )
						dateFormat.setTimeZone( savedTimeZone );
				}
			}

			// only Date, no Time
			if ( !existTime )
			{
				dateFormat = DateFormatFactory.getDateInstance( i, locale );
				TimeZone savedTimeZone = null;
				if( timeZone != null )
				{
					savedTimeZone = dateFormat.getTimeZone( );

				catch ( ParseException e1 )
				{
				}
				finally
				{
					if( savedTimeZone != null )
						dateFormat.setTimeZone( savedTimeZone );

		// for the String can not be parsed, throws a BirtException
		if ( resultDate == null )
		{
			throw new CoreException(
					ResourceConstants.CONVERT_FAILS,
					new Object[]{
							source.toString( ), "Date"


	/**
	 * Convert a string to a Date instance according to the TimeZone value
	 *
	 * @param source
	 * @param timeZone
	 * @return

			}
		}
	}

	/**
	 * A temp solution to the adoption of ICU4J in BIRT. It is a simple
	 * delegation to toDateWithCheck( String, Locale ).
	 *
	 * @param source
	 * @param locale
	 * @return Date

	 * in DateFormat.SHORT case instead of all cases.
	 * 		Year is not lower than 0.
	 * 		Month is from 1 to 12.
	 * 		Day is from 1 to 31.
	 * @param source
	 * @param locale
	 * @return Date

		// check whether conversion is correct
		if ( DateUtil.checkValid( dateFormat, source ) == false )
		{
			throw new CoreException(
					ResourceConstants.CONVERT_FAILS,
					new Object[]{
							source.toString( ), "Date"

	/**
	 * Boolean -> Double
	 * 		true 	-> 1
	 * 		others 	-> 0
	 * Date -> Double
	 * 		Date.getTime();
	 * String -> Double

						}
						return new Double( number.doubleValue( ));
					}

					throw new CoreException( ResourceConstants.CONVERT_FAILS,
							new Object[]{
									source.toString( ), "Double"

		}
	}


	/**
	 * Number -> String
	 * 		Number.toString()


	/**
	 * Convert an object to an locale neutral String value. For Date values we will convert to ISO8601 format.
	 *
	 * @param source
	 * @return
	 * @throws BirtException

		{
			return ((Number) source).toString( );
		}
		else
		{
		return toLimitedSizeString( source );
		}
	}

	/**
	 * Number -> String
	 * 		Number.toString()

		{
			return toString( (Number) source, locale );
		}
		else
		{
			return toLimitedSizeString( source );
		}
	}

	/**
	 *
	 * @param source
	 * @return
	 */

	}

	/**
	 *
	 * @param source
	 * @param locale
	 * @return

		}
		return nf.format( source );
	}

	/**
	 * Converting Blob to/from other types is not currently supported
	 * @param source


	/**
	 * Converts a Java class to its corresponding data type constant
	 * defined in DataType
	 */
	public static int toApiDataType( Class clazz )
	{

		else if ( clazz == Boolean.class )
			return DataType.BOOLEAN_TYPE;
        else if ( clazz == Object.class )
            return DataType.OBJECT_TYPE;

		// any other types are not recognized nor supported;
		return DataType.UNKNOWN_TYPE;
	}

	/**
	 * Converts an ODA data type code to its
	 * corresponding Data Engine API data type constant
	 * defined in DataType.
	 * @param odaDataTypeCode   an ODA data type code

	}

	/**
	 * Convert object to a suitable type from its value
	 * Object -> Integer -> Double -> BigDecimal -> Date -> String
	 */
	public static Object toAutoValue( Object evaValue )

	}

	/**
	 * convert object to Integer. If fails, return null.
	 * Object -> Integer
	 */
	public static Integer toIntegerValue( Object evaValue )

	/**
	 * Convert String without specified locale to java.util.Date
	 * Try to format the given String for JRE default Locale,
	 * if it fails, try to format the String for Locale.US
	 * @param source
	 *            the String to be convert
	 * @param locate


	/**
	 * convert String with ISO8601 date format to java.util.Date
	 *
	 * @param source
	 *            the String to be convert
	 * @param locate

		}
		catch ( ParseException e1 )
		{
			throw new CoreException(
					ResourceConstants.CONVERT_FAILS,
					new Object[]{
							source.toString( ), "Date"


	/**
	 * Call org.eclipse.birt.core.format.DateFormatter
	 *
	 * @param source
	 * @return
	 */

     * JavaObject -> java.lang.Object<br>
     * </i>
	 * @param odaDataTypeCode   an ODA data type code
	 * @return  the ODI type class that corresponds with
	 *          the specified ODA data type
	 * @throws BirtException if the specified ODA data type is not a supported type
	 */

	}

	/**
	 * Converts an ODI type class to its corresponding
	 * ODA data type code. <br>
	 * <b>ODI Type Class -> ODA Data Type</b><br>
	 * <i>java.lang.Integer -> Integer<br>

        else if ( odiTypeClass == java.sql.Date.class )
            odaType = Types.DATE;
        else if ( odiTypeClass == java.util.Date.class )
            odaType = Types.TIMESTAMP;
		else if ( odiTypeClass == Blob.class )
			odaType = Types.BLOB;
		else if ( odiTypeClass == Clob.class )


		return odaType;
	}

	private static boolean isConvertableToInteger( Number n )
	{
		assert n != null;

		long longValue = n.longValue( );
		return longValue >= Integer.MIN_VALUE && longValue <= Integer.MAX_VALUE;

	}

	private static boolean isConvertableToDouble( Number n )
	{
		assert n != null;

		double doubleValue = n.doubleValue( );
		return !Double.isInfinite( doubleValue );

	}
}


Lines 25-31 Link Here

(-)src/org/eclipse/birt/report/model/api/util/DataTypeConvertUtil.java (-7 / +10 lines)
25	* Returns the corresponding parameter type choice with the given column	25	* Returns the corresponding parameter type choice with the given column
26	* data type. The column data type values are defined in	26	* data type. The column data type values are defined in
27	* <code>DesignChoiceConstants</code> can be one of the followings:	27	* <code>DesignChoiceConstants</code> can be one of the followings:
28	*	28	*
29	* <ul>	29	* <ul>
30	* <li><code>COLUMN_DATA_TYPE_BOOLEAN</code>	30	* <li><code>COLUMN_DATA_TYPE_BOOLEAN</code>
31	* <li><code>COLUMN_DATA_TYPE_DATETIME</code>	31	* <li><code>COLUMN_DATA_TYPE_DATETIME</code>
Lines 36-43 Link Here
36	* <li><code>COLUMN_DATA_TYPE_INTEGER</code>	36	* <li><code>COLUMN_DATA_TYPE_INTEGER</code>
37	* <li><code>COLUMN_DATA_TYPE_STRING</code>	37	* <li><code>COLUMN_DATA_TYPE_STRING</code>
38	* </ul>	38	* </ul>
39	*	39	*
40	*	40	*
41	* @param columnType	41	* @param columnType
42	* the column data type	42	* the column data type
43	* @return the parameter type	43	* @return the parameter type
Lines 62-68 Link Here
62	\|\| DesignChoiceConstants.COLUMN_DATA_TYPE_INTEGER	62	\|\| DesignChoiceConstants.COLUMN_DATA_TYPE_INTEGER
63	.equals( columnType )	63	.equals( columnType )
64	\|\| DesignChoiceConstants.COLUMN_DATA_TYPE_STRING	64	\|\| DesignChoiceConstants.COLUMN_DATA_TYPE_STRING
65	.equals( columnType ) )	65	.equals( columnType )
		66	\|\| DesignChoiceConstants.COLUMN_DATA_TYPE_OBJECT
		67	.equals( columnType ) )
66	return DataTypeConversionUtil.converToParamType( columnType );	68	return DataTypeConversionUtil.converToParamType( columnType );
67		69
68	return columnType;	70	return columnType;
Lines 72-78 Link Here
72	* Returns the corresponding column data type choice with the given	74	* Returns the corresponding column data type choice with the given
73	* parameter type. The column data type values are defined in	75	* parameter type. The column data type values are defined in
74	* <code>DesignChoiceConstants</code> can be one of the followings:	76	* <code>DesignChoiceConstants</code> can be one of the followings:
75	*	77	*
76	* <ul>	78	* <ul>
77	* <li><code>PARAM_TYPE_BOOLEAN</code>	79	* <li><code>PARAM_TYPE_BOOLEAN</code>
78	* <li><code>PARAM_TYPE_DATETIME</code>	80	* <li><code>PARAM_TYPE_DATETIME</code>
Lines 83-89 Link Here
83	* <li><code>PARAM_TYPE_INTEGER</code>	85	* <li><code>PARAM_TYPE_INTEGER</code>
84	* <li><code>PARAM_TYPE_STRING</code>	86	* <li><code>PARAM_TYPE_STRING</code>
85	* </ul>	87	* </ul>
86	*	88	*
87	* @param paramType	89	* @param paramType
88	* the parameter type	90	* the parameter type
89	* @return the column data type	91	* @return the column data type
Lines 101-107 Link Here
101	\|\| DesignChoiceConstants.PARAM_TYPE_DECIMAL.equals( paramType )	103	\|\| DesignChoiceConstants.PARAM_TYPE_DECIMAL.equals( paramType )
102	\|\| DesignChoiceConstants.PARAM_TYPE_FLOAT.equals( paramType )	104	\|\| DesignChoiceConstants.PARAM_TYPE_FLOAT.equals( paramType )
103	\|\| DesignChoiceConstants.PARAM_TYPE_INTEGER.equals( paramType )	105	\|\| DesignChoiceConstants.PARAM_TYPE_INTEGER.equals( paramType )
104	\|\| DesignChoiceConstants.PARAM_TYPE_STRING.equals( paramType ) )	106	\|\| DesignChoiceConstants.PARAM_TYPE_STRING.equals( paramType )
		107	\|\| DesignChoiceConstants.PARAM_TYPE_OBJECT.equals( paramType ))
105	return DataTypeConversionUtil.converToColumnDataType( paramType );	108	return DataTypeConversionUtil.converToColumnDataType( paramType );
106		109
107	return paramType;	110	return paramType;




Choices.paramType.any=Any
Choices.paramType.date=Date
Choices.paramType.time=Time
Choices.paramType.javaObject=Java Object

#6.paramControl
Choices.paramControl.text-box=Text Box

Choices.columnDataType.time=Time
Choices.columnDataType.date=Date
Choices.columnDataType.blob=Blob
Choices.columnDataType.javaObject=Java Object

#54. searchType
Choices.searchType.any=Any

Structure.HighlightRule.border.right.color=Color
Structure.HighlightRule.background.color=Background Color
Structure.HighlightRule.format.dateTime=Date Time Format
Structure.HighlightRule.format.number=Number Format
Structure.HighlightRule.format.number.align=Number Alignment  
Structure.HighlightRule.format.string=String Format
Structure.HighlightRule.font.family=Font

Lines 17-23 Link Here

(-)src/org/eclipse/birt/report/model/util/DataTypeConversionUtil.java (-3 / +7 lines)
17	/**	17	/**
18	* The utility class to convert values between parameter type choices and column	18	* The utility class to convert values between parameter type choices and column
19	* data type choices.	19	* data type choices.
20	*	20	*
21	*/	21	*/
22		22
23	public class DataTypeConversionUtil	23	public class DataTypeConversionUtil
Lines 26-32 Link Here
26	/**	26	/**
27	* Returns the corresponding parameter type choice with the given column	27	* Returns the corresponding parameter type choice with the given column
28	* data type.	28	* data type.
29	*	29	*
30	* @param columnType	30	* @param columnType
31	* the column data type	31	* the column data type
32	* @return the parameter type	32	* @return the parameter type
Lines 58-63 Link Here
58	return DesignChoiceConstants.PARAM_TYPE_STRING;	58	return DesignChoiceConstants.PARAM_TYPE_STRING;
59	if ( DesignChoiceConstants.COLUMN_DATA_TYPE_BLOB.equals( columnType ) )	59	if ( DesignChoiceConstants.COLUMN_DATA_TYPE_BLOB.equals( columnType ) )
60	return DesignChoiceConstants.PARAM_TYPE_ANY;	60	return DesignChoiceConstants.PARAM_TYPE_ANY;
		61	if ( DesignChoiceConstants.COLUMN_DATA_TYPE_OBJECT.equals( columnType ) )
		62	return DesignChoiceConstants.PARAM_TYPE_OBJECT;
61		63
62	return columnType;	64	return columnType;
63	}	65	}
Lines 65-71 Link Here
65	/**	67	/**
66	* Returns the corresponding column data type choice with the given	68	* Returns the corresponding column data type choice with the given
67	* parameter type.	69	* parameter type.
68	*	70	*
69	* @param paramType	71	* @param paramType
70	* the parameter type	72	* the parameter type
71	* @return the column data type	73	* @return the column data type
Lines 94-99 Link Here
94	return DesignChoiceConstants.COLUMN_DATA_TYPE_INTEGER;	96	return DesignChoiceConstants.COLUMN_DATA_TYPE_INTEGER;
95	if ( DesignChoiceConstants.PARAM_TYPE_STRING.equals( paramType ) )	97	if ( DesignChoiceConstants.PARAM_TYPE_STRING.equals( paramType ) )
96	return DesignChoiceConstants.COLUMN_DATA_TYPE_STRING;	98	return DesignChoiceConstants.COLUMN_DATA_TYPE_STRING;
		99	if ( DesignChoiceConstants.PARAM_TYPE_OBJECT.equals( paramType ) )
		100	return DesignChoiceConstants.COLUMN_DATA_TYPE_OBJECT;
97		101
98	return paramType;	102	return paramType;
99	}	103	}




/**
 * This class collects commonly-used choice constants. These constants define
 * the internal value of choices for several property choice constants.
 *
 * @see ReportDesignConstants
 */


	// fontFamily

	public static final String CHOICE_FONT_FAMILY = "fontFamily"; //$NON-NLS-1$
	public static final String FONT_FAMILY_SERIF = "serif"; //$NON-NLS-1$
	public static final String FONT_FAMILY_SANS_SERIF = "sans-serif"; //$NON-NLS-1$
	public static final String FONT_FAMILY_CURSIVE = "cursive"; //$NON-NLS-1$
	public static final String FONT_FAMILY_FANTASY = "fantasy"; //$NON-NLS-1$
	public static final String FONT_FAMILY_MONOSPACE = "monospace"; //$NON-NLS-1$


	public static final String PARAM_TYPE_DATETIME = "dateTime"; //$NON-NLS-1$
	public static final String PARAM_TYPE_BOOLEAN = "boolean"; //$NON-NLS-1$
	public static final String PARAM_TYPE_INTEGER = "integer"; //$NON-NLS-1$
	public static final String PARAM_TYPE_OBJECT = "javaObject"; //$NON-NLS-1$
	/**
	 * @deprecated Now any is not supported.
	 */

	public static final String FORMAT_TYPE_REPORTLET = "reportlet"; //$NON-NLS-1$
	public static final String FORMAT_TYPE_EXCEL = "excel"; //$NON-NLS-1$
	public static final String FORMAT_TYPE_WORD = "word"; //$NON-NLS-1$
	public static final String FORMAT_TYPE_POWERPOINT = "powerpoint"; //$NON-NLS-1$
	public static final String FORMAT_TYPE_DOC = "doc"; //$NON-NLS-1$
	/**
	 * ImageRefType -- The image reference type. The first constant is the name

	public static final String COLUMN_DATA_TYPE_DATE = "date";//$NON-NLS-1$
	public static final String COLUMN_DATA_TYPE_TIME = "time";//$NON-NLS-1$
	public static final String COLUMN_DATA_TYPE_BLOB = "blob";//$NON-NLS-1$
	public static final String COLUMN_DATA_TYPE_OBJECT = "javaObject";//$NON-NLS-1$

	/**
	 * searchType -- The search type for column hint The first constant is the

	 */

	public static final String CHOICE_NUMBER_FORMAT_TYPE = "numberFormat"; //$NON-NLS-1$
	public static final String NUMBER_FORMAT_TYPE_UNFORMATTED = "Unformatted"; //$NON-NLS-1$
	public static final String NUMBER_FORMAT_TYPE_GENERAL_NUMBER = "General Number"; //$NON-NLS-1$
	public static final String NUMBER_FORMAT_TYPE_CURRENCY = "Currency"; //$NON-NLS-1$
	public static final String NUMBER_FORMAT_TYPE_FIXED = "Fixed"; //$NON-NLS-1$

	public static final String STRING_FORMAT_TYPE_UPPERCASE = ">"; //$NON-NLS-1$
	public static final String STRING_FORMAT_TYPE_LOWERCASE = "<"; //$NON-NLS-1$
	public static final String STRING_FORMAT_TYPE_CUSTOM = "Custom"; //$NON-NLS-1$
	public static final String STRING_FORMAT_TYPE_ZIP_CODE = "Zip Code"; //$NON-NLS-1$
	public static final String STRING_FORMAT_TYPE_ZIP_CODE_4 = "Zip Code + 4"; //$NON-NLS-1$
	public static final String STRING_FORMAT_TYPE_PHONE_NUMBER = "Phone Number"; //$NON-NLS-1$
	public static final String STRING_FORMAT_TYPE_SOCIAL_SECURITY_NUMBER = "Social Security Number"; //$NON-NLS-1$


	public static final String AGGREGATION_FUNCTION_IS_TOP_N = "is-top-n"; //$NON-NLS-1$
	public static final String AGGREGATION_FUNCTION_IS_BOTTOM_N = "is-bottom-n"; //$NON-NLS-1$
	public static final String AGGREGATION_FUNCTION_IS_TOP_N_PERCENT = "is-top-n-percent"; //$NON-NLS-1$
	public static final String AGGREGATION_FUNCTION_IS_BOTTOM_N_PERCENT = "is-bottom-n-percent"; //$NON-NLS-1$
	public static final String AGGREGATION_FUNCTION_PERCENT_RANK = "percent-rank"; //$NON-NLS-1$
	public static final String AGGREGATION_FUNCTION_PERCENTILE = "percentile"; //$NON-NLS-1$
	public static final String AGGREGATION_FUNCTION_TOP_QUARTILE = "quartile"; //$NON-NLS-1$


	/**
	 * Choice constants for workMode.
	 *
	 */
	public static final String CHOICE_VARIABLE_TYPE = "variableType"; //$NON-NLS-1$
	public static final String VARIABLE_TYPE_REPORT = "report"; //$NON-NLS-1$




	}

	/**
	 * register model aggregation function names with build-in function names
	 */
	private static void registerAggregationFunction( )
	{

		aggrAdapterMap.put( DesignChoiceConstants.AGGREGATION_FUNCTION_RANK,
				IBuildInAggregation.TOTAL_RANK_FUNC );
	}

	/**
	 * register model filter operator with dte's IConditionalExpression operator
	 */

	/**
	 * This method is used to register the Java Script Objects which are defined in the scope of
	 * source ResultSet ( might be IResultSet or CubeCursor ) to target scope. One possible client
	 * of this method is Report Engine. A classic use case is that instead of register its own "row" object
	 * the Report Engine can simply call this method with proper argument so that the "row" object
	 * registered in IResultIterator's scope, that is, JSResultSetRow, can be accessed by engine using
	 * engine scope.
	 *
	 * @param targetScope
	 * @param source
	 */

					scope ) );
		}
	}

	/**
	 * Adapts a Model data type (string) to Data Engine data type constant
	 * (integer) on column

			return DataType.BOOLEAN_TYPE;
		if ( modelDataType.equals( DesignChoiceConstants.COLUMN_DATA_TYPE_BLOB ) )
			return DataType.BLOB_TYPE;
		if ( modelDataType.equals( DesignChoiceConstants.COLUMN_DATA_TYPE_OBJECT ) )
		    return DataType.OBJECT_TYPE;

		return DataType.UNKNOWN_TYPE;
	}

	/**
	 * @param type: a Data Engine data type
	 * @return Data Engine data types compatible with <code>type</code>, including <code>type</code> itself

				return new int[]{ DataType.DECIMAL_TYPE, DataType.DOUBLE_TYPE, DataType.INTEGER_TYPE };
			case DataType.STRING_TYPE:
				return new int[]{ DataType.STRING_TYPE, DataType.BOOLEAN_TYPE,
						DataType.DECIMAL_TYPE, DataType.DOUBLE_TYPE, DataType.INTEGER_TYPE,
						DataType.DATE_TYPE, DataType.BLOB_TYPE, DataType.BINARY_TYPE,
						DataType.SQL_DATE_TYPE, DataType.SQL_TIME_TYPE };
			case DataType.DATE_TYPE:
				return new int[]{ DataType.DATE_TYPE, DataType.SQL_DATE_TYPE, DataType.SQL_TIME_TYPE };

				return new int[]{ DataType.BLOB_TYPE };
			case DataType.BINARY_TYPE:
				return new int[]{ DataType.BINARY_TYPE };
            case DataType.OBJECT_TYPE:
                return new int[]{ DataType.OBJECT_TYPE };
			case DataType.SQL_DATE_TYPE:
				return new int[]{ DataType.SQL_DATE_TYPE, DataType.DATE_TYPE };
			case DataType.SQL_TIME_TYPE:

				throw new AdapterException( ResourceConstants.INVALID_DATA_TYPE, type );
		}
	}

	/**
	 * Adapter dte's data type to model data type
	 * @param apiDataType

			return DesignChoiceConstants.COLUMN_DATA_TYPE_BOOLEAN;
		else if ( apiDataType == DataType.BLOB_TYPE )
			return DesignChoiceConstants.COLUMN_DATA_TYPE_BLOB;
		else if ( apiDataType == DataType.OBJECT_TYPE )
            return DesignChoiceConstants.COLUMN_DATA_TYPE_OBJECT;

		return DesignChoiceConstants.COLUMN_DATA_TYPE_ANY;
	}

	/**
	 *
	 * @param modelAggrType
	 * @return
	 * @throws AdapterException

		Object o = aggrAdapterMap.get( modelAggrType );
		return o == null ? modelAggrType : o.toString( );
	}

	/**
	 * This method is used to adapter model filter's operator into dte's
	 * operator
	 *
	 * @param modelOpr
	 * @return
	 */

		else
			return IConditionalExpression.OP_NONE;
	}

	/**
	 * Get the rollup aggregation name. If the function is TOTAL_AVE_FUNC,
	 * TOTAL_COUNT_FUNC, or TOTAL_COUNT_DISTINCT_FUNC, return TOTAL_SUM_FUNC as
	 * measure function name
	 *
	 * @param functionName
	 * @return
	 */

		else
			return func;
	}

	/**
	 * This method is used to adapter model sort direction into dte's direction.
	 *
	 * @param dir
	 * @return
	 */

		return DesignChoiceConstants.SORT_DIRECTION_DESC.equals( modelSortDir )
				? ISortDefinition.SORT_DESC : ISortDefinition.SORT_ASC;
	}

	/**
	 *
	 * @param type
	 * @return
	 */

			typeNum = DataType.INTEGER_TYPE;
		return typeNum;
	}

	/**
	 *
	 * @param dteDTName
	 * @return
	 */

			modelDataType = DesignChoiceConstants.PARAM_TYPE_TIME;
		return modelDataType;
	}

	/**
	 *
	 * @param name
	 * @return
	 */

				? org.eclipse.birt.data.aggregation.impl.Constants.EXPRESSION_NAME
				: name;
	}

	/**
	 * Get the parameter value from .rptconfig file if it does exist
	 *
	 * @return Object[] the parameter value
	 */
	public static Object getParamValueFromConfigFile( ScalarParameterHandle paramHandle )

		String reportConfigName = designFileName.substring( 0, index + 1 )
				+ "rptconfig";
		final File file = new File( reportConfigName );


		if ( AccessController.doPrivileged( new PrivilegedAction<Boolean>()
				{
			  public Boolean run()

					{
						try
						{
							return DataTypeUtil.convert(
									values.get( 0 ), DataAdapterUtil.modelDataTypeToCoreDataType( parameterHandle.getDataType() ) );
						}
						catch ( BirtException e )

							return null;
						}
					}

					try {
						Object[] reValues = new Object[values.size()];
						for (int i = 0; i < reValues.length; i++)
						{
							reValues[i] = DataTypeUtil.convert(
									values.get(i), DataAdapterUtil.modelDataTypeToCoreDataType(parameterHandle.getDataType()));
						}
						return reValues;


	/**
	 * Delete the last "_" part
	 *
	 * @param name
	 * @return String
	 */


	/**
	 * Checks whether the parameter value is null in the rptconfig file
	 *
	 * @param varName
	 * @param varValue
	 * @param newParaName

		return varName.toLowerCase( ).startsWith( "__isnull" )
				&& varValue.equals( newParaName );
	}

	private static class JSResultIteratorObject extends ScriptableObject
	{
		/**
		 *
		 */
		private static final long serialVersionUID = 684728008759347940L;
		private ILinkedResult it;
		private IResultIterator currentIterator;

		JSResultIteratorObject( ILinkedResult it )
		{
			this.it = it;
			if ( it.getCurrentResultType( ) == ILinkedResult.TYPE_TABLE )
				this.currentIterator = (IResultIterator) it.getCurrentResult( );
		}

		public String getClassName( )
		{
			return "JSResultIteratorObject";

Lines 27-33 Link Here

(-)src/org/eclipse/birt/report/model/adapter/oda/impl/ODAFactory.java (-3 / +7 lines)
27		27
28	/*	28	/*
29	* (non-Javadoc)	29	* (non-Javadoc)
30	*	30	*
31	* @see	31	* @see
32	* org.eclipse.birt.report.model.adapter.oda.api.IODAFactory#getUpdatedDataType	32	* org.eclipse.birt.report.model.adapter.oda.api.IODAFactory#getUpdatedDataType
33	* (java.lang.String, java.lang.String, int, java.lang.String,	33	* (java.lang.String, java.lang.String, int, java.lang.String,
Lines 99-104 Link Here
99	return DesignChoiceConstants.COLUMN_DATA_TYPE_BOOLEAN;	99	return DesignChoiceConstants.COLUMN_DATA_TYPE_BOOLEAN;
100	case DataType.BLOB_TYPE :	100	case DataType.BLOB_TYPE :
101	return DesignChoiceConstants.COLUMN_DATA_TYPE_BLOB;	101	return DesignChoiceConstants.COLUMN_DATA_TYPE_BLOB;
		102	case DataType.OBJECT_TYPE :
		103	return DesignChoiceConstants.COLUMN_DATA_TYPE_OBJECT;
102	case DataType.BINARY_TYPE :	104	case DataType.BINARY_TYPE :
103	case DataType.ANY_TYPE :	105	case DataType.ANY_TYPE :
104	default :	106	default :
Lines 126-131 Link Here
126	return DesignChoiceConstants.PARAM_TYPE_FLOAT;	128	return DesignChoiceConstants.PARAM_TYPE_FLOAT;
127	case DataType.BOOLEAN_TYPE :	129	case DataType.BOOLEAN_TYPE :
128	return DesignChoiceConstants.PARAM_TYPE_BOOLEAN;	130	return DesignChoiceConstants.PARAM_TYPE_BOOLEAN;
		131	case DataType.OBJECT_TYPE :
		132	return DesignChoiceConstants.PARAM_TYPE_OBJECT;
129	case DataType.ANY_TYPE :	133	case DataType.ANY_TYPE :
130	case DataType.BLOB_TYPE :	134	case DataType.BLOB_TYPE :
131	case DataType.BINARY_TYPE :	135	case DataType.BINARY_TYPE :
Lines 136-142 Link Here
136		140
137	/**	141	/**
138	* Converts DTE api data type to ROM defined data type.	142	* Converts DTE api data type to ROM defined data type.
139	*	143	*
140	* @param choiceName	144	* @param choiceName
141	* the ROM choice to map	145	* the ROM choice to map
142	* @param apiDataType	146	* @param apiDataType
Lines 163-169 Link Here
163		167
164	/**	168	/**
165	* Checks whether the oda data type is compaible with rom data type.	169	* Checks whether the oda data type is compaible with rom data type.
166	*	170	*
167	* @param romDataType	171	* @param romDataType
168	* the rom data type in string	172	* the rom data type in string
169	* @param odaDataTypeCode	173	* @param odaDataTypeCode




 *  Actuate Corporation - initial API and implementation
 *
 ******************************************************************************
 */

package org.eclipse.birt.data.engine.odaconsumer;


import org.eclipse.datatools.connectivity.oda.IClob;

/**
 * <code>ParameterHint</code> provides hints to map static
 * parameter definitions to runtime parameters.
 */
public class ParameterHint

	private boolean m_isInputMode;
	private boolean m_isOutputMode;
	private boolean m_isNullable;

    private static final int UNKNOWN_NATIVE_TYPE = 0;

	// trace logging variables
	private static String sm_className = ParameterHint.class.getName();

	 * @param parameterName	the parameter name.
	 * @param isInputMode	whether this is an input parameter.
	 * @param isOutputMode	whether this is an output parameter.
	 * @throws IllegalArgumentException	if the parameter name is null or
	 * 									empty.
	 */
	public ParameterHint( String parameterName, boolean isInputMode, boolean isOutputMode )

		if( sm_logger.isLoggingEnterExitLevel() )
		    sm_logger.entering( sm_className, methodName,
		            			new Object[] { parameterName, new Boolean( isInputMode ), new Boolean( isOutputMode ) } );

		if( parameterName == null || parameterName.length() == 0 )
		{
			String localizedMessage =
				DataResourceHandle.getInstance().getMessage( ResourceConstants.PARAMETER_NAME_CANNOT_BE_EMPTY_OR_NULL );

			sm_logger.logp( Level.SEVERE, sm_className, methodName,
							"The given parameter is null or empty." ); //$NON-NLS-1$
			throw new IllegalArgumentException( localizedMessage );
		}

		m_name = parameterName;
		m_isInputMode = isInputMode;
		m_isOutputMode = isOutputMode;

		m_isInputOptional = true;
		m_isNullable = true;

	    sm_logger.exiting( sm_className, methodName, this );
	}


	{
		return m_name;
	}

	/**
	 * Sets the parameter 1-based position for this parameter hint.
	 * @param position	the 1-based position of the parameter.
	 * @throws IllegalArgumentException	if the parameter position is less
	 * 									than 1.
	 */
	public void setPosition( int position )
	{
		final String methodName = "setPosition( int )"; //$NON-NLS-1$

		if( position < 1 )
		{
			String localizedMessage =
				DataResourceHandle.getInstance().getMessage( ResourceConstants.PARAMETER_POSITION_CANNOT_BE_LESS_THAN_ONE );
			sm_logger.logp( Level.SEVERE, sm_className, methodName,
					"Invalid parameter position {0} ", new Integer( position ) ); //$NON-NLS-1$
			throw new IllegalArgumentException( localizedMessage );
		}

		m_position = position;
	}

	/**
	 * Returns the parameter 1-based position for this parameter hint.
	 * @return	the 1-based position of the parameter; 0 if no position was
	 * 			specified.
	 */
	public int getPosition()
	{
		return m_position;
	}

	/**
	 * Sets the data type for this parameter hint.
	 * @param dataType	the data type of the parameter.

	public void setDataType( Class dataType )
	{
		final String methodName = "setDataType( Class )"; //$NON-NLS-1$

		// validate given data type;
		// data type for a hint may be null
		boolean isValid = false;
		if( dataType == null ||
		        dataType == Integer.class ||
		        dataType == Double.class ||
		        dataType == String.class ||

		        dataType == Timestamp.class ||
		        dataType == IBlob.class ||
		        dataType == IClob.class ||
                dataType == Boolean.class ||
                dataType == Object.class)
		{
		    isValid = true;
		}

		// input parameter does not support Blob/Clob data type
		if( isValid && isInputMode() && dataType != null )
		{
		    if( dataType == IBlob.class ||
		        dataType == IClob.class )
		    {
			    isValid = false;
		    }
		}

		if( isValid == false )
		{
			String localizedMessage =
				DataResourceHandle.getInstance().getMessage( ResourceConstants.UNSUPPORTED_PARAMETER_VALUE_TYPE,
				        new Object[]{ dataType } );
			sm_logger.logp( Level.SEVERE, sm_className, methodName,
					"Invalid parameter data type {0}.", dataType ); //$NON-NLS-1$
			throw new IllegalArgumentException( localizedMessage );
		}

		m_dataType = dataType;
	}

	/**
	 * Returns the parameter ODI data type specified in this parameter hint.
     * Note that this may not be the most effective data type to use.

    {
        return m_nativeDataType;
    }

	/**
	 * Sets whether the input parameter is optional.  Has
	 * no effect on non-input parameters.
	 * @param isInputOptional	whether this input parameter is optional.
	 */

		if( m_isInputMode )
			m_isInputOptional = isInputOptional;
	}

	/**
	 * Returns whether the input parameter is optional.  Returns true
	 * for non-input parameters.
	 * @return	true if the input parameter is optional or if this is a
	 * 			non-input parameter, false otherwise.
	 */
	public boolean isInputOptional()
	{
		return ( m_isInputMode ) ? m_isInputOptional : true;
	}

	/**
	 * Sets whether the parameter can be null.
	 * @param isNullable	whether this parameter can be null.

	{
		m_isNullable = isNullable;
	}

	/**
	 * Returns whether the parameter can be null.
	 * @return	true if the parameter can be null, false otherwise.

	{
		return m_isNullable;
	}

	/**
	 * Sets the default value of the input parameter.  Has no effect on
	 * non-input parameters.
	 * @param defaultInputValue	the default value.
	 */

		if( m_isInputMode )
			m_defaultInputValue = defaultInputValue;
	}

	/**
	 * Gets the default vlaue of the input parameter.  Returns null for
	 * non-input parameters.
	 * @return	the default value of the input parameter, or null for
	 * 			non-input parameters.
	 */
	public String getDefaultInputValue()
	{
		return ( m_isInputMode ) ? m_defaultInputValue : null;
	}

	/**
	 * Returns whether the parameter is an input parameter.
	 * @return	true if the parameter is an input parameter, false otherwise.


    /**
     * Sets the native name of the parameter as known to the underlying data source.
     * @param nativeName The native name to set; may be a null value if the name
     *          is not available or this parameter is not named.
     */
    public void setNativeName( String nativeName )
    {
        m_nativeName = nativeName;
    }

	/**
     * Returns the native name of the parameter as known to the underlying data source.
     * @return the parameter native name, or
     *          null if the name is not available or this parameter is not named.
     */
    public String getNativeName()

    }

    /**
     * Sets hether this parameter allows binding with multiple input values.
     * Has no effect on non-input parameters.
     * @param isMultiInputValuesAllowed  true if multiple input values are allowed;
     *          false if at most a single input value is allowed.

    }

    /**
	 * Helper method to update this <code>ParameterHint</code> with
	 * information from another <code>ParameterHint</code>.
	 * @param hint	the <code>ParameterHint</code> instance.
	 */

		sm_logger.entering( sm_className, methodName, hint );

		m_name = hint.m_name;

		// don't update if the specified hint has default values

	    if( hint.m_nativeName != null )


		if( hint.m_position != 0 )
			m_position = hint.m_position;

		if( hint.m_dataType != null )
			m_dataType = hint.m_dataType;

        if( hint.m_nativeDataType != UNKNOWN_NATIVE_TYPE )
            m_nativeDataType = hint.m_nativeDataType;

		m_isInputOptional = hint.m_isInputOptional;
		m_defaultInputValue = hint.m_defaultInputValue;
		m_isInputMode = hint.m_isInputMode;


		sm_logger.exiting( sm_className, methodName, this );
	}

    /**
     * Returns the most effective ODI data type defined in the hint.
     * It determines the best type to use based on the native data type defined.
     * @param odaDataSourceId   underlying ODA driver's data source id that defines
     *                          the native data type mappings
     * @param dataSetType       type of data set; may be null
     *                          if the oda data source has only one type of data set
     * @return  the most effective ODI data type to use
     */
    public Class getEffectiveDataType( String odaDataSourceId, String dataSetType )
    {
        return DataTypeUtil.toTypeClass(
                    getEffectiveOdaType( odaDataSourceId, dataSetType ) );
    }

    int getEffectiveOdaType( String odaDataSourceId, String dataSetType )
    {
        /* The BIRT DtE ODI data type specified in a parameter hint may be based on
         * what an user manually entered in BIRT host designer, and was not necessarily
         * validated against an underlying ODA driver.
         * Whereas, the native data type in hint, if available, is provided by
         * a custom ODA designer.  It is thus a more reliable type to use in a retry.
         * So we first try to use the native data type for the effective ODA data type.
         */
        if( getNativeDataType() != UNKNOWN_NATIVE_TYPE )
        {

            if( odaType != Types.NULL )
                return odaType;     // found valid native to oda type mapping
        }

        // no native data type mapping info, use the BIRT DtE ODI API data type instead
        Class typeInHint = getDataType();
        return DataTypeUtil.toOdaType( typeInHint );
    }

}




	}

	/**
	 *
	 * @throws DataException
	 */
	private void initIndex( ) throws DataException

		{
			Class valueClass = resultClass.getFieldValueClass( i + 1 );
			assert valueClass != null;
			if ( IClob.class.isAssignableFrom( valueClass ) )
				clobIndexList.add( new Integer( i ) );
			else if ( IBlob.class.isAssignableFrom( valueClass ) )
				blobIndexList.add( new Integer( i ) );;
		}
		clobIndex = toIntArray( clobIndexList );

	}

	/**
	 *
	 * @param integerList
	 * @return
	 */

		}
		return reArray;
	}

	/**
	 *
	 * @return
	 */
	boolean hasClobOrBlob( )

	}

	/**
	 *
	 * @return
	 */
	int[] getClobIndexArray( )

	}

	/**
	 *
	 * @return
	 */
	int[] getBlobIndexArray( )
	{
		return blobIndex;
	}

}




import java.util.Date;

/**
 *
 */

public class DataType

	public static final int BYTES_TYPE = 102;
	public static final int SQL_DATE_TYPE = org.eclipse.birt.core.data.DataType.SQL_DATE_TYPE;
	public static final int SQL_TIME_TYPE = org.eclipse.birt.core.data.DataType.SQL_TIME_TYPE;


	private static final String[] names = {
			"Boolean",


	/**
	 * Gets the description of a data type.
	 *
	 * @param typeCode
	 *            Data type enumeration value
	 * @return Textual description of data type. "Unknown" if an undefined data


	/**
	 * Gets the Java class used to represent the specified data type.
	 *
	 * @return Class for the specified data type. If data type is unknown or
	 *         ANY, returns null.
	 */

	}

	/**
	 *
	 * @param objClass
	 * @return
	 */

Return to bug 178897

Lines 118-123 Link Here

(-)src/org/eclipse/birt/report/model/i18n/Messages.properties (-1 / +3 lines)
118	Choices.paramType.any=Any	118	Choices.paramType.any=Any
119	Choices.paramType.date=Date	119	Choices.paramType.date=Date
120	Choices.paramType.time=Time	120	Choices.paramType.time=Time
		121	Choices.paramType.javaObject=Java Object
121		122
122	#6.paramControl	123	#6.paramControl
123	Choices.paramControl.text-box=Text Box	124	Choices.paramControl.text-box=Text Box
Lines 429-434 Link Here
429	Choices.columnDataType.time=Time	430	Choices.columnDataType.time=Time
430	Choices.columnDataType.date=Date	431	Choices.columnDataType.date=Date
431	Choices.columnDataType.blob=Blob	432	Choices.columnDataType.blob=Blob
		433	Choices.columnDataType.javaObject=Java Object
432		434
433	#54. searchType	435	#54. searchType
434	Choices.searchType.any=Any	436	Choices.searchType.any=Any
Lines 1871-1877 Link Here
1871	Structure.HighlightRule.border.right.color=Color	1873	Structure.HighlightRule.border.right.color=Color
1872	Structure.HighlightRule.background.color=Background Color	1874	Structure.HighlightRule.background.color=Background Color
1873	Structure.HighlightRule.format.dateTime=Date Time Format	1875	Structure.HighlightRule.format.dateTime=Date Time Format
1874	Structure.HighlightRule.format.number= NumbervFormat	1876	Structure.HighlightRule.format.number=Number Format
1875	Structure.HighlightRule.format.number.align=Number Alignment	1877	Structure.HighlightRule.format.number.align=Number Alignment
1876	Structure.HighlightRule.format.string=String Format	1878	Structure.HighlightRule.format.string=String Format
1877	Structure.HighlightRule.font.family=Font	1879	Structure.HighlightRule.font.family=Font

Lines 8-16 Link Here

(-)src/org/eclipse/birt/core/data/DataType.java (-22 / +26 lines)
8	*	8	*
9	* Contributors:	9	* Contributors:
10	* Actuate Corporation - initial API and implementation	10	* Actuate Corporation - initial API and implementation
11	*	11	*
12	*************************************************************************	12	*************************************************************************
13	*/	13	*/
14	package org.eclipse.birt.core.data;	14	package org.eclipse.birt.core.data;
15		15
16	import java.math.BigDecimal;	16	import java.math.BigDecimal;
Lines 25-42 Link Here
25	public static final int UNKNOWN_TYPE = -1;	25	public static final int UNKNOWN_TYPE = -1;
26	public static final int ANY_TYPE = 0;	26	public static final int ANY_TYPE = 0;
27	public static final int BOOLEAN_TYPE = 1;	27	public static final int BOOLEAN_TYPE = 1;
28	public static final int INTEGER_TYPE = 2;	28	public static final int INTEGER_TYPE = 2;
29	public static final int DOUBLE_TYPE = 3;	29	public static final int DOUBLE_TYPE = 3;
30	public static final int DECIMAL_TYPE = 4;	30	public static final int DECIMAL_TYPE = 4;
31	public static final int STRING_TYPE = 5;	31	public static final int STRING_TYPE = 5;
32	public static final int DATE_TYPE = 6;	32	public static final int DATE_TYPE = 6;
33	public static final int BLOB_TYPE = 7;	33	public static final int BLOB_TYPE = 7;
34	public static final int BINARY_TYPE = 8;	34	public static final int BINARY_TYPE = 8;
35	public static final int SQL_DATE_TYPE = 9;	35	public static final int SQL_DATE_TYPE = 9;
36	public static final int SQL_TIME_TYPE = 10;	36	public static final int SQL_TIME_TYPE = 10;
37		37	public static final int OBJECT_TYPE = 11;
38	private static final String[] names =	38
39	{	39	private static final String[] names =
		40	{
40	"Any",	41	"Any",
41	"Boolean",	42	"Boolean",
42	"Integer",	43	"Integer",
Lines 47-55 Link Here
47	"Blob",	48	"Blob",
48	"Binary",	49	"Binary",
49	"Date",	50	"Date",
50	"Time"	51	"Time",
		52	"Java Object"
51	};	53	};
52		54
53	public static final String ANY_TYPE_NAME = names[0];	55	public static final String ANY_TYPE_NAME = names[0];
54	public static final String BOOLEAN_TYPE_NAME = names[1];	56	public static final String BOOLEAN_TYPE_NAME = names[1];
55	public static final String INTEGER_TYPE_NAME = names[2];	57	public static final String INTEGER_TYPE_NAME = names[2];
Lines 61-69 Link Here
61	public static final String BINARY_TYPE_NAME = names[8];	63	public static final String BINARY_TYPE_NAME = names[8];
62	public static final String SQL_DATE_TYPE_NAME = names[9];	64	public static final String SQL_DATE_TYPE_NAME = names[9];
63	public static final String SQL_TIME_TYPE_NAME = names[10];	65	public static final String SQL_TIME_TYPE_NAME = names[10];
64		66	public static final String JAVA_OBJECT_TYPE_NAME = names[11];
65	private static final Class[] classes =	67
66	{	68	private static final Class[] classes =
		69	{
67	AnyType.class,	70	AnyType.class,
68	Boolean.class,	71	Boolean.class,
69	Integer.class,	72	Integer.class,
Lines 75-82 Link Here
75	byte[].class,	78	byte[].class,
76	java.sql.Date.class,	79	java.sql.Date.class,
77	java.sql.Time.class,	80	java.sql.Time.class,
		81	Object.class
78	};	82	};
79		83
80	/**	84	/**
81	* Gets the description of a data type.	85	* Gets the description of a data type.
82	* @param typeCode Data type enumeration value	86	* @param typeCode Data type enumeration value
Lines 89-99 Link Here
89	return new String( "Unknown" );	93	return new String( "Unknown" );
90	}	94	}
91	return names[typeCode];	95	return names[typeCode];
92	}	96	}
93		97
94	/**	98	/**
95	* Gets the Java class used to represent the specified data type.	99	* Gets the Java class used to represent the specified data type.
96	* @return Class for the specified data type. If data type is unknown or ANY, returns null.	100	* @return Class for the specified data type. If data type is unknown or ANY, returns null.
97	*/	101	*/
98	public static Class getClass( int typeCode )	102	public static Class getClass( int typeCode )
99	{	103	{
Lines 103-111 Link Here
103	}	107	}
104	return classes[typeCode];	108	return classes[typeCode];
105	}	109	}
106		110
107	/**	111	/**
108	*	112	*
109	* @param objClass	113	* @param objClass
110	* @return	114	* @return
111	*/	115	*/
Lines 120-132 Link Here
120	}	124	}
121	return false;	125	return false;
122	}	126	}
123		127
124	/**	128	/**
125	* Other type can be found in JDK, such as Integer and String, but AnyType	129	* Other type can be found in JDK, such as Integer and String, but AnyType
126	* have to be manually created to make it correspond to "Any" name.	130	* have to be manually created to make it correspond to "Any" name.
127	*/	131	*/
128	public static final class AnyType	132	public static final class AnyType
129	{	133	{
130	};	134	};
131		135
132	}	136	}

Lines 187-192 Link Here

(-)src/org/eclipse/birt/report/model/elements/rom.def (+3 lines)
187	<Choice displayNameID="Choices.paramType.integer" name="integer"/>	187	<Choice displayNameID="Choices.paramType.integer" name="integer"/>
188	<Choice displayNameID="Choices.paramType.date" name="date"/>	188	<Choice displayNameID="Choices.paramType.date" name="date"/>
189	<Choice displayNameID="Choices.paramType.time" name="time"/>	189	<Choice displayNameID="Choices.paramType.time" name="time"/>
		190	<Choice displayNameID="Choices.paramType.javaObject" name="javaObject"/>
190	</ChoiceType>	191	</ChoiceType>
191	<ChoiceType name="paramValueType">	192	<ChoiceType name="paramValueType">
192	<Choice displayNameID="Choices.paramValueType.static" name="static"/>	193	<Choice displayNameID="Choices.paramValueType.static" name="static"/>
Lines 394-399 Link Here
394	<Choice displayNameID="Choices.columnDataType.date" name="date"/>	395	<Choice displayNameID="Choices.columnDataType.date" name="date"/>
395	<Choice displayNameID="Choices.columnDataType.time" name="time"/>	396	<Choice displayNameID="Choices.columnDataType.time" name="time"/>
396	<Choice displayNameID="Choices.columnDataType.blob" name="blob"/>	397	<Choice displayNameID="Choices.columnDataType.blob" name="blob"/>
		398	<Choice displayNameID="Choices.columnDataType.javaObject" name="javaObject"/>
		399
397	<!-- not supported now	400	<!-- not supported now
398	<Choice displayNameID="Choices.columnDataType.structure" name="structure"/>	401	<Choice displayNameID="Choices.columnDataType.structure" name="structure"/>
399	<Choice displayNameID="Choices.columnDataType.table" name="table"/>	402	<Choice displayNameID="Choices.columnDataType.table" name="table"/>

Lines 14-20 Link Here

(-)src/org/eclipse/birt/report/model/api/elements/DesignChoiceConstants.java (-10 / +12 lines)
14	/**	14	/**
15	* This class collects commonly-used choice constants. These constants define	15	* This class collects commonly-used choice constants. These constants define
16	* the internal value of choices for several property choice constants.	16	* the internal value of choices for several property choice constants.
17	*	17	*
18	* @see ReportDesignConstants	18	* @see ReportDesignConstants
19	*/	19	*/
20		20
Lines 24-32 Link Here
24	// fontFamily	24	// fontFamily
25		25
26	public static final String CHOICE_FONT_FAMILY = "fontFamily"; //$NON-NLS-1$	26	public static final String CHOICE_FONT_FAMILY = "fontFamily"; //$NON-NLS-1$
27	public static final String FONT_FAMILY_SERIF = "serif"; //$NON-NLS-1$	27	public static final String FONT_FAMILY_SERIF = "serif"; //$NON-NLS-1$
28	public static final String FONT_FAMILY_SANS_SERIF = "sans-serif"; //$NON-NLS-1$	28	public static final String FONT_FAMILY_SANS_SERIF = "sans-serif"; //$NON-NLS-1$
29	public static final String FONT_FAMILY_CURSIVE = "cursive"; //$NON-NLS-1$	29	public static final String FONT_FAMILY_CURSIVE = "cursive"; //$NON-NLS-1$
30	public static final String FONT_FAMILY_FANTASY = "fantasy"; //$NON-NLS-1$	30	public static final String FONT_FAMILY_FANTASY = "fantasy"; //$NON-NLS-1$
31	public static final String FONT_FAMILY_MONOSPACE = "monospace"; //$NON-NLS-1$	31	public static final String FONT_FAMILY_MONOSPACE = "monospace"; //$NON-NLS-1$
32		32
Lines 257-262 Link Here
257	public static final String PARAM_TYPE_DATETIME = "dateTime"; //$NON-NLS-1$	257	public static final String PARAM_TYPE_DATETIME = "dateTime"; //$NON-NLS-1$
258	public static final String PARAM_TYPE_BOOLEAN = "boolean"; //$NON-NLS-1$	258	public static final String PARAM_TYPE_BOOLEAN = "boolean"; //$NON-NLS-1$
259	public static final String PARAM_TYPE_INTEGER = "integer"; //$NON-NLS-1$	259	public static final String PARAM_TYPE_INTEGER = "integer"; //$NON-NLS-1$
		260	public static final String PARAM_TYPE_OBJECT = "javaObject"; //$NON-NLS-1$
260	/**	261	/**
261	* @deprecated Now any is not supported.	262	* @deprecated Now any is not supported.
262	*/	263	*/
Lines 459-465 Link Here
459	public static final String FORMAT_TYPE_REPORTLET = "reportlet"; //$NON-NLS-1$	460	public static final String FORMAT_TYPE_REPORTLET = "reportlet"; //$NON-NLS-1$
460	public static final String FORMAT_TYPE_EXCEL = "excel"; //$NON-NLS-1$	461	public static final String FORMAT_TYPE_EXCEL = "excel"; //$NON-NLS-1$
461	public static final String FORMAT_TYPE_WORD = "word"; //$NON-NLS-1$	462	public static final String FORMAT_TYPE_WORD = "word"; //$NON-NLS-1$
462	public static final String FORMAT_TYPE_POWERPOINT = "powerpoint"; //$NON-NLS-1$	463	public static final String FORMAT_TYPE_POWERPOINT = "powerpoint"; //$NON-NLS-1$
463	public static final String FORMAT_TYPE_DOC = "doc"; //$NON-NLS-1$	464	public static final String FORMAT_TYPE_DOC = "doc"; //$NON-NLS-1$
464	/**	465	/**
465	* ImageRefType -- The image reference type. The first constant is the name	466	* ImageRefType -- The image reference type. The first constant is the name
Lines 517-522 Link Here
517	public static final String COLUMN_DATA_TYPE_DATE = "date";//$NON-NLS-1$	518	public static final String COLUMN_DATA_TYPE_DATE = "date";//$NON-NLS-1$
518	public static final String COLUMN_DATA_TYPE_TIME = "time";//$NON-NLS-1$	519	public static final String COLUMN_DATA_TYPE_TIME = "time";//$NON-NLS-1$
519	public static final String COLUMN_DATA_TYPE_BLOB = "blob";//$NON-NLS-1$	520	public static final String COLUMN_DATA_TYPE_BLOB = "blob";//$NON-NLS-1$
		521	public static final String COLUMN_DATA_TYPE_OBJECT = "javaObject";//$NON-NLS-1$
520		522
521	/**	523	/**
522	* searchType -- The search type for column hint The first constant is the	524	* searchType -- The search type for column hint The first constant is the
Lines 618-624 Link Here
618	*/	620	*/
619		621
620	public static final String CHOICE_NUMBER_FORMAT_TYPE = "numberFormat"; //$NON-NLS-1$	622	public static final String CHOICE_NUMBER_FORMAT_TYPE = "numberFormat"; //$NON-NLS-1$
621	public static final String NUMBER_FORMAT_TYPE_UNFORMATTED = "Unformatted"; //$NON-NLS-1$	623	public static final String NUMBER_FORMAT_TYPE_UNFORMATTED = "Unformatted"; //$NON-NLS-1$
622	public static final String NUMBER_FORMAT_TYPE_GENERAL_NUMBER = "General Number"; //$NON-NLS-1$	624	public static final String NUMBER_FORMAT_TYPE_GENERAL_NUMBER = "General Number"; //$NON-NLS-1$
623	public static final String NUMBER_FORMAT_TYPE_CURRENCY = "Currency"; //$NON-NLS-1$	625	public static final String NUMBER_FORMAT_TYPE_CURRENCY = "Currency"; //$NON-NLS-1$
624	public static final String NUMBER_FORMAT_TYPE_FIXED = "Fixed"; //$NON-NLS-1$	626	public static final String NUMBER_FORMAT_TYPE_FIXED = "Fixed"; //$NON-NLS-1$
Lines 677-684 Link Here
677	public static final String STRING_FORMAT_TYPE_UPPERCASE = ">"; //$NON-NLS-1$	679	public static final String STRING_FORMAT_TYPE_UPPERCASE = ">"; //$NON-NLS-1$
678	public static final String STRING_FORMAT_TYPE_LOWERCASE = "<"; //$NON-NLS-1$	680	public static final String STRING_FORMAT_TYPE_LOWERCASE = "<"; //$NON-NLS-1$
679	public static final String STRING_FORMAT_TYPE_CUSTOM = "Custom"; //$NON-NLS-1$	681	public static final String STRING_FORMAT_TYPE_CUSTOM = "Custom"; //$NON-NLS-1$
680	public static final String STRING_FORMAT_TYPE_ZIP_CODE = "Zip Code"; //$NON-NLS-1$	682	public static final String STRING_FORMAT_TYPE_ZIP_CODE = "Zip Code"; //$NON-NLS-1$
681	public static final String STRING_FORMAT_TYPE_ZIP_CODE_4 = "Zip Code + 4"; //$NON-NLS-1$	683	public static final String STRING_FORMAT_TYPE_ZIP_CODE_4 = "Zip Code + 4"; //$NON-NLS-1$
682	public static final String STRING_FORMAT_TYPE_PHONE_NUMBER = "Phone Number"; //$NON-NLS-1$	684	public static final String STRING_FORMAT_TYPE_PHONE_NUMBER = "Phone Number"; //$NON-NLS-1$
683	public static final String STRING_FORMAT_TYPE_SOCIAL_SECURITY_NUMBER = "Social Security Number"; //$NON-NLS-1$	685	public static final String STRING_FORMAT_TYPE_SOCIAL_SECURITY_NUMBER = "Social Security Number"; //$NON-NLS-1$
684		686
Lines 818-824 Link Here
818	public static final String AGGREGATION_FUNCTION_IS_TOP_N = "is-top-n"; //$NON-NLS-1$	820	public static final String AGGREGATION_FUNCTION_IS_TOP_N = "is-top-n"; //$NON-NLS-1$
819	public static final String AGGREGATION_FUNCTION_IS_BOTTOM_N = "is-bottom-n"; //$NON-NLS-1$	821	public static final String AGGREGATION_FUNCTION_IS_BOTTOM_N = "is-bottom-n"; //$NON-NLS-1$
820	public static final String AGGREGATION_FUNCTION_IS_TOP_N_PERCENT = "is-top-n-percent"; //$NON-NLS-1$	822	public static final String AGGREGATION_FUNCTION_IS_TOP_N_PERCENT = "is-top-n-percent"; //$NON-NLS-1$
821	public static final String AGGREGATION_FUNCTION_IS_BOTTOM_N_PERCENT = "is-bottom-n-percent"; //$NON-NLS-1$	823	public static final String AGGREGATION_FUNCTION_IS_BOTTOM_N_PERCENT = "is-bottom-n-percent"; //$NON-NLS-1$
822	public static final String AGGREGATION_FUNCTION_PERCENT_RANK = "percent-rank"; //$NON-NLS-1$	824	public static final String AGGREGATION_FUNCTION_PERCENT_RANK = "percent-rank"; //$NON-NLS-1$
823	public static final String AGGREGATION_FUNCTION_PERCENTILE = "percentile"; //$NON-NLS-1$	825	public static final String AGGREGATION_FUNCTION_PERCENTILE = "percentile"; //$NON-NLS-1$
824	public static final String AGGREGATION_FUNCTION_TOP_QUARTILE = "quartile"; //$NON-NLS-1$	826	public static final String AGGREGATION_FUNCTION_TOP_QUARTILE = "quartile"; //$NON-NLS-1$
Lines 939-945 Link Here
939		941
940	/**	942	/**
941	* Choice constants for workMode.	943	* Choice constants for workMode.
942	*	944	*
943	*/	945	*/
944	public static final String CHOICE_VARIABLE_TYPE = "variableType"; //$NON-NLS-1$	946	public static final String CHOICE_VARIABLE_TYPE = "variableType"; //$NON-NLS-1$
945	public static final String VARIABLE_TYPE_REPORT = "report"; //$NON-NLS-1$	947	public static final String VARIABLE_TYPE_REPORT = "report"; //$NON-NLS-1$

Lines 59-65 Link Here

(-)src/org/eclipse/birt/report/data/adapter/api/DataAdapterUtil.java (-37 / +44 lines)
59	}	59	}
60		60
61	/**	61	/**
62	* register model aggregation function names with build-in function names	62	* register model aggregation function names with build-in function names
63	*/	63	*/
64	private static void registerAggregationFunction( )	64	private static void registerAggregationFunction( )
65	{	65	{
Lines 122-128 Link Here
122	aggrAdapterMap.put( DesignChoiceConstants.AGGREGATION_FUNCTION_RANK,	122	aggrAdapterMap.put( DesignChoiceConstants.AGGREGATION_FUNCTION_RANK,
123	IBuildInAggregation.TOTAL_RANK_FUNC );	123	IBuildInAggregation.TOTAL_RANK_FUNC );
124	}	124	}
125		125
126	/**	126	/**
127	* register model filter operator with dte's IConditionalExpression operator	127	* register model filter operator with dte's IConditionalExpression operator
128	*/	128	*/
Lines 177-187 Link Here
177	/**	177	/**
178	* This method is used to register the Java Script Objects which are defined in the scope of	178	* This method is used to register the Java Script Objects which are defined in the scope of
179	* source ResultSet ( might be IResultSet or CubeCursor ) to target scope. One possible client	179	* source ResultSet ( might be IResultSet or CubeCursor ) to target scope. One possible client
180	* of this method is Report Engine. A classic use case is that instead of register its own "row" object	180	* of this method is Report Engine. A classic use case is that instead of register its own "row" object
181	* the Report Engine can simply call this method with proper argument so that the "row" object	181	* the Report Engine can simply call this method with proper argument so that the "row" object
182	* registered in IResultIterator's scope, that is, JSResultSetRow, can be accessed by engine using	182	* registered in IResultIterator's scope, that is, JSResultSetRow, can be accessed by engine using
183	* engine scope.	183	* engine scope.
184	*	184	*
185	* @param targetScope	185	* @param targetScope
186	* @param source	186	* @param source
187	*/	187	*/
Lines 205-211 Link Here
205	scope ) );	205	scope ) );
206	}	206	}
207	}	207	}
208		208
209	/**	209	/**
210	* Adapts a Model data type (string) to Data Engine data type constant	210	* Adapts a Model data type (string) to Data Engine data type constant
211	* (integer) on column	211	* (integer) on column
Lines 234-242 Link Here
234	return DataType.BOOLEAN_TYPE;	234	return DataType.BOOLEAN_TYPE;
235	if ( modelDataType.equals( DesignChoiceConstants.COLUMN_DATA_TYPE_BLOB ) )	235	if ( modelDataType.equals( DesignChoiceConstants.COLUMN_DATA_TYPE_BLOB ) )
236	return DataType.BLOB_TYPE;	236	return DataType.BLOB_TYPE;
		237	if ( modelDataType.equals( DesignChoiceConstants.COLUMN_DATA_TYPE_OBJECT ) )
		238	return DataType.OBJECT_TYPE;
		239
237	return DataType.UNKNOWN_TYPE;	240	return DataType.UNKNOWN_TYPE;
238	}	241	}
239		242
240	/**	243	/**
241	* @param type: a Data Engine data type	244	* @param type: a Data Engine data type
242	* @return Data Engine data types compatible with <code>type</code>, including <code>type</code> itself	245	* @return Data Engine data types compatible with <code>type</code>, including <code>type</code> itself
Lines 256-263 Link Here
256	return new int[]{ DataType.DECIMAL_TYPE, DataType.DOUBLE_TYPE, DataType.INTEGER_TYPE };	259	return new int[]{ DataType.DECIMAL_TYPE, DataType.DOUBLE_TYPE, DataType.INTEGER_TYPE };
257	case DataType.STRING_TYPE:	260	case DataType.STRING_TYPE:
258	return new int[]{ DataType.STRING_TYPE, DataType.BOOLEAN_TYPE,	261	return new int[]{ DataType.STRING_TYPE, DataType.BOOLEAN_TYPE,
259	DataType.DECIMAL_TYPE, DataType.DOUBLE_TYPE, DataType.INTEGER_TYPE,	262	DataType.DECIMAL_TYPE, DataType.DOUBLE_TYPE, DataType.INTEGER_TYPE,
260	DataType.DATE_TYPE, DataType.BLOB_TYPE, DataType.BINARY_TYPE,	263	DataType.DATE_TYPE, DataType.BLOB_TYPE, DataType.BINARY_TYPE,
261	DataType.SQL_DATE_TYPE, DataType.SQL_TIME_TYPE };	264	DataType.SQL_DATE_TYPE, DataType.SQL_TIME_TYPE };
262	case DataType.DATE_TYPE:	265	case DataType.DATE_TYPE:
263	return new int[]{ DataType.DATE_TYPE, DataType.SQL_DATE_TYPE, DataType.SQL_TIME_TYPE };	266	return new int[]{ DataType.DATE_TYPE, DataType.SQL_DATE_TYPE, DataType.SQL_TIME_TYPE };
Lines 265-270 Link Here
265	return new int[]{ DataType.BLOB_TYPE };	268	return new int[]{ DataType.BLOB_TYPE };
266	case DataType.BINARY_TYPE:	269	case DataType.BINARY_TYPE:
267	return new int[]{ DataType.BINARY_TYPE };	270	return new int[]{ DataType.BINARY_TYPE };
		271	case DataType.OBJECT_TYPE:
		272	return new int[]{ DataType.OBJECT_TYPE };
268	case DataType.SQL_DATE_TYPE:	273	case DataType.SQL_DATE_TYPE:
269	return new int[]{ DataType.SQL_DATE_TYPE, DataType.DATE_TYPE };	274	return new int[]{ DataType.SQL_DATE_TYPE, DataType.DATE_TYPE };
270	case DataType.SQL_TIME_TYPE:	275	case DataType.SQL_TIME_TYPE:
Lines 273-279 Link Here
273	throw new AdapterException( ResourceConstants.INVALID_DATA_TYPE, type );	278	throw new AdapterException( ResourceConstants.INVALID_DATA_TYPE, type );
274	}	279	}
275	}	280	}
276		281
277	/**	282	/**
278	* Adapter dte's data type to model data type	283	* Adapter dte's data type to model data type
279	* @param apiDataType	284	* @param apiDataType
Lines 299-310 Link Here
299	return DesignChoiceConstants.COLUMN_DATA_TYPE_BOOLEAN;	304	return DesignChoiceConstants.COLUMN_DATA_TYPE_BOOLEAN;
300	else if ( apiDataType == DataType.BLOB_TYPE )	305	else if ( apiDataType == DataType.BLOB_TYPE )
301	return DesignChoiceConstants.COLUMN_DATA_TYPE_BLOB;	306	return DesignChoiceConstants.COLUMN_DATA_TYPE_BLOB;
		307	else if ( apiDataType == DataType.OBJECT_TYPE )
		308	return DesignChoiceConstants.COLUMN_DATA_TYPE_OBJECT;
302		309
303	return DesignChoiceConstants.COLUMN_DATA_TYPE_ANY;	310	return DesignChoiceConstants.COLUMN_DATA_TYPE_ANY;
304	}	311	}
305		312
306	/**	313	/**
307	*	314	*
308	* @param modelAggrType	315	* @param modelAggrType
309	* @return	316	* @return
310	* @throws AdapterException	317	* @throws AdapterException
Lines 315-325 Link Here
315	Object o = aggrAdapterMap.get( modelAggrType );	322	Object o = aggrAdapterMap.get( modelAggrType );
316	return o == null ? modelAggrType : o.toString( );	323	return o == null ? modelAggrType : o.toString( );
317	}	324	}
318		325
319	/**	326	/**
320	* This method is used to adapter model filter's operator into dte's	327	* This method is used to adapter model filter's operator into dte's
321	* operator	328	* operator
322	*	329	*
323	* @param modelOpr	330	* @param modelOpr
324	* @return	331	* @return
325	*/	332	*/
Lines 331-342 Link Here
331	else	338	else
332	return IConditionalExpression.OP_NONE;	339	return IConditionalExpression.OP_NONE;
333	}	340	}
334		341
335	/**	342	/**
336	* Get the rollup aggregation name. If the function is TOTAL_AVE_FUNC,	343	* Get the rollup aggregation name. If the function is TOTAL_AVE_FUNC,
337	* TOTAL_COUNT_FUNC, or TOTAL_COUNT_DISTINCT_FUNC, return TOTAL_SUM_FUNC as	344	* TOTAL_COUNT_FUNC, or TOTAL_COUNT_DISTINCT_FUNC, return TOTAL_SUM_FUNC as
338	* measure function name	345	* measure function name
339	*	346	*
340	* @param functionName	347	* @param functionName
341	* @return	348	* @return
342	*/	349	*/
Lines 360-369 Link Here
360	else	367	else
361	return func;	368	return func;
362	}	369	}
363		370
364	/**	371	/**
365	* This method is used to adapter model sort direction into dte's direction.	372	* This method is used to adapter model sort direction into dte's direction.
366	*	373	*
367	* @param dir	374	* @param dir
368	* @return	375	* @return
369	*/	376	*/
Lines 372-380 Link Here
372	return DesignChoiceConstants.SORT_DIRECTION_DESC.equals( modelSortDir )	379	return DesignChoiceConstants.SORT_DIRECTION_DESC.equals( modelSortDir )
373	? ISortDefinition.SORT_DESC : ISortDefinition.SORT_ASC;	380	? ISortDefinition.SORT_DESC : ISortDefinition.SORT_ASC;
374	}	381	}
375		382
376	/**	383	/**
377	*	384	*
378	* @param type	385	* @param type
379	* @return	386	* @return
380	*/	387	*/
Lines 399-407 Link Here
399	typeNum = DataType.INTEGER_TYPE;	406	typeNum = DataType.INTEGER_TYPE;
400	return typeNum;	407	return typeNum;
401	}	408	}
402		409
403	/**	410	/**
404	*	411	*
405	* @param dteDTName	412	* @param dteDTName
406	* @return	413	* @return
407	*/	414	*/
Lines 430-438 Link Here
430	modelDataType = DesignChoiceConstants.PARAM_TYPE_TIME;	437	modelDataType = DesignChoiceConstants.PARAM_TYPE_TIME;
431	return modelDataType;	438	return modelDataType;
432	}	439	}
433		440
434	/**	441	/**
435	*	442	*
436	* @param name	443	* @param name
437	* @return	444	* @return
438	*/	445	*/
Lines 442-451 Link Here
442	? org.eclipse.birt.data.aggregation.impl.Constants.EXPRESSION_NAME	449	? org.eclipse.birt.data.aggregation.impl.Constants.EXPRESSION_NAME
443	: name;	450	: name;
444	}	451	}
445		452
446	/**	453	/**
447	* Get the parameter value from .rptconfig file if it does exist	454	* Get the parameter value from .rptconfig file if it does exist
448	*	455	*
449	* @return Object[] the parameter value	456	* @return Object[] the parameter value
450	*/	457	*/
451	public static Object getParamValueFromConfigFile( ScalarParameterHandle paramHandle )	458	public static Object getParamValueFromConfigFile( ScalarParameterHandle paramHandle )
Lines 463-470 Link Here
463	String reportConfigName = designFileName.substring( 0, index + 1 )	470	String reportConfigName = designFileName.substring( 0, index + 1 )
464	+ "rptconfig";	471	+ "rptconfig";
465	final File file = new File( reportConfigName );	472	final File file = new File( reportConfigName );
466		473
467		474
468	if ( AccessController.doPrivileged( new PrivilegedAction<Boolean>()	475	if ( AccessController.doPrivileged( new PrivilegedAction<Boolean>()
469	{	476	{
470	public Boolean run()	477	public Boolean run()
Lines 529-535 Link Here
529	{	536	{
530	try	537	try
531	{	538	{
532	return DataTypeUtil.convert(	539	return DataTypeUtil.convert(
533	values.get( 0 ), DataAdapterUtil.modelDataTypeToCoreDataType( parameterHandle.getDataType() ) );	540	values.get( 0 ), DataAdapterUtil.modelDataTypeToCoreDataType( parameterHandle.getDataType() ) );
534	}	541	}
535	catch ( BirtException e )	542	catch ( BirtException e )
Lines 537-548 Link Here
537	return null;	544	return null;
538	}	545	}
539	}	546	}
540		547
541	try {	548	try {
542	Object[] reValues = new Object[values.size()];	549	Object[] reValues = new Object[values.size()];
543	for (int i = 0; i < reValues.length; i++)	550	for (int i = 0; i < reValues.length; i++)
544	{	551	{
545	reValues[i] = DataTypeUtil.convert(	552	reValues[i] = DataTypeUtil.convert(
546	values.get(i), DataAdapterUtil.modelDataTypeToCoreDataType(parameterHandle.getDataType()));	553	values.get(i), DataAdapterUtil.modelDataTypeToCoreDataType(parameterHandle.getDataType()));
547	}	554	}
548	return reValues;	555	return reValues;
Lines 559-565 Link Here
559		566
560	/**	567	/**
561	* Delete the last "_" part	568	* Delete the last "_" part
562	*	569	*
563	* @param name	570	* @param name
564	* @return String	571	* @return String
565	*/	572	*/
Lines 571-577 Link Here
571		578
572	/**	579	/**
573	* Checks whether the parameter value is null in the rptconfig file	580	* Checks whether the parameter value is null in the rptconfig file
574	*	581	*
575	* @param varName	582	* @param varName
576	* @param varValue	583	* @param varValue
577	* @param newParaName	584	* @param newParaName
Lines 583-605 Link Here
583	return varName.toLowerCase( ).startsWith( "__isnull" )	590	return varName.toLowerCase( ).startsWith( "__isnull" )
584	&& varValue.equals( newParaName );	591	&& varValue.equals( newParaName );
585	}	592	}
586		593
587	private static class JSResultIteratorObject extends ScriptableObject	594	private static class JSResultIteratorObject extends ScriptableObject
588	{	595	{
589	/**	596	/**
590	*	597	*
591	*/	598	*/
592	private static final long serialVersionUID = 684728008759347940L;	599	private static final long serialVersionUID = 684728008759347940L;
593	private ILinkedResult it;	600	private ILinkedResult it;
594	private IResultIterator currentIterator;	601	private IResultIterator currentIterator;
595		602
596	JSResultIteratorObject( ILinkedResult it )	603	JSResultIteratorObject( ILinkedResult it )
597	{	604	{
598	this.it = it;	605	this.it = it;
599	if ( it.getCurrentResultType( ) == ILinkedResult.TYPE_TABLE )	606	if ( it.getCurrentResultType( ) == ILinkedResult.TYPE_TABLE )
600	this.currentIterator = (IResultIterator) it.getCurrentResult( );	607	this.currentIterator = (IResultIterator) it.getCurrentResult( );
601	}	608	}
602		609
603	public String getClassName( )	610	public String getClassName( )
604	{	611	{
605	return "JSResultIteratorObject";	612	return "JSResultIteratorObject";

Lines 10-16 Link Here

(-)src/org/eclipse/birt/data/engine/odaconsumer/ParameterHint.java (-63 / +64 lines)
10	* Actuate Corporation - initial API and implementation	10	* Actuate Corporation - initial API and implementation
11	*	11	*
12	******************************************************************************	12	******************************************************************************
13	*/	13	*/
14		14
15	package org.eclipse.birt.data.engine.odaconsumer;	15	package org.eclipse.birt.data.engine.odaconsumer;
16		16
Lines 26-32 Link Here
26	import org.eclipse.datatools.connectivity.oda.IClob;	26	import org.eclipse.datatools.connectivity.oda.IClob;
27		27
28	/**	28	/**
29	* <code>ParameterHint</code> provides hints to map static	29	* <code>ParameterHint</code> provides hints to map static
30	* parameter definitions to runtime parameters.	30	* parameter definitions to runtime parameters.
31	*/	31	*/
32	public class ParameterHint	32	public class ParameterHint
Lines 42-49 Link Here
42	private boolean m_isInputMode;	42	private boolean m_isInputMode;
43	private boolean m_isOutputMode;	43	private boolean m_isOutputMode;
44	private boolean m_isNullable;	44	private boolean m_isNullable;
45		45
46	private static final int UNKNOWN_NATIVE_TYPE = 0;	46	private static final int UNKNOWN_NATIVE_TYPE = 0;
47		47
48	// trace logging variables	48	// trace logging variables
49	private static String sm_className = ParameterHint.class.getName();	49	private static String sm_className = ParameterHint.class.getName();
Lines 55-61 Link Here
55	* @param parameterName the parameter name.	55	* @param parameterName the parameter name.
56	* @param isInputMode whether this is an input parameter.	56	* @param isInputMode whether this is an input parameter.
57	* @param isOutputMode whether this is an output parameter.	57	* @param isOutputMode whether this is an output parameter.
58	* @throws IllegalArgumentException if the parameter name is null or	58	* @throws IllegalArgumentException if the parameter name is null or
59	* empty.	59	* empty.
60	*/	60	*/
61	public ParameterHint( String parameterName, boolean isInputMode, boolean isOutputMode )	61	public ParameterHint( String parameterName, boolean isInputMode, boolean isOutputMode )
Lines 64-87 Link Here
64	if( sm_logger.isLoggingEnterExitLevel() )	64	if( sm_logger.isLoggingEnterExitLevel() )
65	sm_logger.entering( sm_className, methodName,	65	sm_logger.entering( sm_className, methodName,
66	new Object[] { parameterName, new Boolean( isInputMode ), new Boolean( isOutputMode ) } );	66	new Object[] { parameterName, new Boolean( isInputMode ), new Boolean( isOutputMode ) } );
67		67
68	if( parameterName == null \|\| parameterName.length() == 0 )	68	if( parameterName == null \|\| parameterName.length() == 0 )
69	{	69	{
70	String localizedMessage =	70	String localizedMessage =
71	DataResourceHandle.getInstance().getMessage( ResourceConstants.PARAMETER_NAME_CANNOT_BE_EMPTY_OR_NULL );	71	DataResourceHandle.getInstance().getMessage( ResourceConstants.PARAMETER_NAME_CANNOT_BE_EMPTY_OR_NULL );
72		72
73	sm_logger.logp( Level.SEVERE, sm_className, methodName,	73	sm_logger.logp( Level.SEVERE, sm_className, methodName,
74	"The given parameter is null or empty." ); //$NON-NLS-1$	74	"The given parameter is null or empty." ); //$NON-NLS-1$
75	throw new IllegalArgumentException( localizedMessage );	75	throw new IllegalArgumentException( localizedMessage );
76	}	76	}
77		77
78	m_name = parameterName;	78	m_name = parameterName;
79	m_isInputMode = isInputMode;	79	m_isInputMode = isInputMode;
80	m_isOutputMode = isOutputMode;	80	m_isOutputMode = isOutputMode;
81		81
82	m_isInputOptional = true;	82	m_isInputOptional = true;
83	m_isNullable = true;	83	m_isNullable = true;
84		84
85	sm_logger.exiting( sm_className, methodName, this );	85	sm_logger.exiting( sm_className, methodName, this );
86	}	86	}
87		87
Lines 93-131 Link Here
93	{	93	{
94	return m_name;	94	return m_name;
95	}	95	}
96		96
97	/**	97	/**
98	* Sets the parameter 1-based position for this parameter hint.	98	* Sets the parameter 1-based position for this parameter hint.
99	* @param position the 1-based position of the parameter.	99	* @param position the 1-based position of the parameter.
100	* @throws IllegalArgumentException if the parameter position is less	100	* @throws IllegalArgumentException if the parameter position is less
101	* than 1.	101	* than 1.
102	*/	102	*/
103	public void setPosition( int position )	103	public void setPosition( int position )
104	{	104	{
105	final String methodName = "setPosition( int )"; //$NON-NLS-1$	105	final String methodName = "setPosition( int )"; //$NON-NLS-1$
106		106
107	if( position < 1 )	107	if( position < 1 )
108	{	108	{
109	String localizedMessage =	109	String localizedMessage =
110	DataResourceHandle.getInstance().getMessage( ResourceConstants.PARAMETER_POSITION_CANNOT_BE_LESS_THAN_ONE );	110	DataResourceHandle.getInstance().getMessage( ResourceConstants.PARAMETER_POSITION_CANNOT_BE_LESS_THAN_ONE );
111	sm_logger.logp( Level.SEVERE, sm_className, methodName,	111	sm_logger.logp( Level.SEVERE, sm_className, methodName,
112	"Invalid parameter position {0} ", new Integer( position ) ); //$NON-NLS-1$	112	"Invalid parameter position {0} ", new Integer( position ) ); //$NON-NLS-1$
113	throw new IllegalArgumentException( localizedMessage );	113	throw new IllegalArgumentException( localizedMessage );
114	}	114	}
115		115
116	m_position = position;	116	m_position = position;
117	}	117	}
118		118
119	/**	119	/**
120	* Returns the parameter 1-based position for this parameter hint.	120	* Returns the parameter 1-based position for this parameter hint.
121	* @return the 1-based position of the parameter; 0 if no position was	121	* @return the 1-based position of the parameter; 0 if no position was
122	* specified.	122	* specified.
123	*/	123	*/
124	public int getPosition()	124	public int getPosition()
125	{	125	{
126	return m_position;	126	return m_position;
127	}	127	}
128		128
129	/**	129	/**
130	* Sets the data type for this parameter hint.	130	* Sets the data type for this parameter hint.
131	* @param dataType the data type of the parameter.	131	* @param dataType the data type of the parameter.
Lines 134-144 Link Here
134	public void setDataType( Class dataType )	134	public void setDataType( Class dataType )
135	{	135	{
136	final String methodName = "setDataType( Class )"; //$NON-NLS-1$	136	final String methodName = "setDataType( Class )"; //$NON-NLS-1$
137		137
138	// validate given data type;	138	// validate given data type;
139	// data type for a hint may be null	139	// data type for a hint may be null
140	boolean isValid = false;	140	boolean isValid = false;
141	if( dataType == null \|\|	141	if( dataType == null \|\|
142	dataType == Integer.class \|\|	142	dataType == Integer.class \|\|
143	dataType == Double.class \|\|	143	dataType == Double.class \|\|
144	dataType == String.class \|\|	144	dataType == String.class \|\|
Lines 149-182 Link Here
149	dataType == Timestamp.class \|\|	149	dataType == Timestamp.class \|\|
150	dataType == IBlob.class \|\|	150	dataType == IBlob.class \|\|
151	dataType == IClob.class \|\|	151	dataType == IClob.class \|\|
152	dataType == Boolean.class )	152	dataType == Boolean.class \|\|
		153	dataType == Object.class)
153	{	154	{
154	isValid = true;	155	isValid = true;
155	}	156	}
156		157
157	// input parameter does not support Blob/Clob data type	158	// input parameter does not support Blob/Clob data type
158	if( isValid && isInputMode() && dataType != null )	159	if( isValid && isInputMode() && dataType != null )
159	{	160	{
160	if( dataType == IBlob.class \|\|	161	if( dataType == IBlob.class \|\|
161	dataType == IClob.class )	162	dataType == IClob.class )
162	{	163	{
163	isValid = false;	164	isValid = false;
164	}	165	}
165	}	166	}
166		167
167	if( isValid == false )	168	if( isValid == false )
168	{	169	{
169	String localizedMessage =	170	String localizedMessage =
170	DataResourceHandle.getInstance().getMessage( ResourceConstants.UNSUPPORTED_PARAMETER_VALUE_TYPE,	171	DataResourceHandle.getInstance().getMessage( ResourceConstants.UNSUPPORTED_PARAMETER_VALUE_TYPE,
171	new Object[]{ dataType } );	172	new Object[]{ dataType } );
172	sm_logger.logp( Level.SEVERE, sm_className, methodName,	173	sm_logger.logp( Level.SEVERE, sm_className, methodName,
173	"Invalid parameter data type {0}.", dataType ); //$NON-NLS-1$	174	"Invalid parameter data type {0}.", dataType ); //$NON-NLS-1$
174	throw new IllegalArgumentException( localizedMessage );	175	throw new IllegalArgumentException( localizedMessage );
175	}	176	}
176		177
177	m_dataType = dataType;	178	m_dataType = dataType;
178	}	179	}
179		180
180	/**	181	/**
181	* Returns the parameter ODI data type specified in this parameter hint.	182	* Returns the parameter ODI data type specified in this parameter hint.
182	* Note that this may not be the most effective data type to use.	183	* Note that this may not be the most effective data type to use.
Lines 208-216 Link Here
208	{	209	{
209	return m_nativeDataType;	210	return m_nativeDataType;
210	}	211	}
211		212
212	/**	213	/**
213	* Sets whether the input parameter is optional. Has	214	* Sets whether the input parameter is optional. Has
214	* no effect on non-input parameters.	215	* no effect on non-input parameters.
215	* @param isInputOptional whether this input parameter is optional.	216	* @param isInputOptional whether this input parameter is optional.
216	*/	217	*/
Lines 219-236 Link Here
219	if( m_isInputMode )	220	if( m_isInputMode )
220	m_isInputOptional = isInputOptional;	221	m_isInputOptional = isInputOptional;
221	}	222	}
222		223
223	/**	224	/**
224	* Returns whether the input parameter is optional. Returns true	225	* Returns whether the input parameter is optional. Returns true
225	* for non-input parameters.	226	* for non-input parameters.
226	* @return true if the input parameter is optional or if this is a	227	* @return true if the input parameter is optional or if this is a
227	* non-input parameter, false otherwise.	228	* non-input parameter, false otherwise.
228	*/	229	*/
229	public boolean isInputOptional()	230	public boolean isInputOptional()
230	{	231	{
231	return ( m_isInputMode ) ? m_isInputOptional : true;	232	return ( m_isInputMode ) ? m_isInputOptional : true;
232	}	233	}
233		234
234	/**	235	/**
235	* Sets whether the parameter can be null.	236	* Sets whether the parameter can be null.
236	* @param isNullable whether this parameter can be null.	237	* @param isNullable whether this parameter can be null.
Lines 239-245 Link Here
239	{	240	{
240	m_isNullable = isNullable;	241	m_isNullable = isNullable;
241	}	242	}
242		243
243	/**	244	/**
244	* Returns whether the parameter can be null.	245	* Returns whether the parameter can be null.
245	* @return true if the parameter can be null, false otherwise.	246	* @return true if the parameter can be null, false otherwise.
Lines 248-256 Link Here
248	{	249	{
249	return m_isNullable;	250	return m_isNullable;
250	}	251	}
251		252
252	/**	253	/**
253	* Sets the default value of the input parameter. Has no effect on	254	* Sets the default value of the input parameter. Has no effect on
254	* non-input parameters.	255	* non-input parameters.
255	* @param defaultInputValue the default value.	256	* @param defaultInputValue the default value.
256	*/	257	*/
Lines 259-276 Link Here
259	if( m_isInputMode )	260	if( m_isInputMode )
260	m_defaultInputValue = defaultInputValue;	261	m_defaultInputValue = defaultInputValue;
261	}	262	}
262		263
263	/**	264	/**
264	* Gets the default vlaue of the input parameter. Returns null for	265	* Gets the default vlaue of the input parameter. Returns null for
265	* non-input parameters.	266	* non-input parameters.
266	* @return the default value of the input parameter, or null for	267	* @return the default value of the input parameter, or null for
267	* non-input parameters.	268	* non-input parameters.
268	*/	269	*/
269	public String getDefaultInputValue()	270	public String getDefaultInputValue()
270	{	271	{
271	return ( m_isInputMode ) ? m_defaultInputValue : null;	272	return ( m_isInputMode ) ? m_defaultInputValue : null;
272	}	273	}
273		274
274	/**	275	/**
275	* Returns whether the parameter is an input parameter.	276	* Returns whether the parameter is an input parameter.
276	* @return true if the parameter is an input parameter, false otherwise.	277	* @return true if the parameter is an input parameter, false otherwise.
Lines 291-307 Link Here
291		292
292	/**	293	/**
293	* Sets the native name of the parameter as known to the underlying data source.	294	* Sets the native name of the parameter as known to the underlying data source.
294	* @param nativeName The native name to set; may be a null value if the name	295	* @param nativeName The native name to set; may be a null value if the name
295	* is not available or this parameter is not named.	296	* is not available or this parameter is not named.
296	*/	297	*/
297	public void setNativeName( String nativeName )	298	public void setNativeName( String nativeName )
298	{	299	{
299	m_nativeName = nativeName;	300	m_nativeName = nativeName;
300	}	301	}
301		302
302	/**	303	/**
303	* Returns the native name of the parameter as known to the underlying data source.	304	* Returns the native name of the parameter as known to the underlying data source.
304	* @return the parameter native name, or	305	* @return the parameter native name, or
305	* null if the name is not available or this parameter is not named.	306	* null if the name is not available or this parameter is not named.
306	*/	307	*/
307	public String getNativeName()	308	public String getNativeName()
Lines 310-316 Link Here
310	}	311	}
311		312
312	/**	313	/**
313	* Sets hether this parameter allows binding with multiple input values.	314	* Sets hether this parameter allows binding with multiple input values.
314	* Has no effect on non-input parameters.	315	* Has no effect on non-input parameters.
315	* @param isMultiInputValuesAllowed true if multiple input values are allowed;	316	* @param isMultiInputValuesAllowed true if multiple input values are allowed;
316	* false if at most a single input value is allowed.	317	* false if at most a single input value is allowed.
Lines 333-339 Link Here
333	}	334	}
334		335
335	/**	336	/**
336	* Helper method to update this <code>ParameterHint</code> with	337	* Helper method to update this <code>ParameterHint</code> with
337	* information from another <code>ParameterHint</code>.	338	* information from another <code>ParameterHint</code>.
338	* @param hint the <code>ParameterHint</code> instance.	339	* @param hint the <code>ParameterHint</code> instance.
339	*/	340	*/
Lines 343-349 Link Here
343	sm_logger.entering( sm_className, methodName, hint );	344	sm_logger.entering( sm_className, methodName, hint );
344		345
345	m_name = hint.m_name;	346	m_name = hint.m_name;
346		347
347	// don't update if the specified hint has default values	348	// don't update if the specified hint has default values
348		349
349	if( hint.m_nativeName != null )	350	if( hint.m_nativeName != null )
Lines 351-363 Link Here
351		352
352	if( hint.m_position != 0 )	353	if( hint.m_position != 0 )
353	m_position = hint.m_position;	354	m_position = hint.m_position;
354		355
355	if( hint.m_dataType != null )	356	if( hint.m_dataType != null )
356	m_dataType = hint.m_dataType;	357	m_dataType = hint.m_dataType;
357		358
358	if( hint.m_nativeDataType != UNKNOWN_NATIVE_TYPE )	359	if( hint.m_nativeDataType != UNKNOWN_NATIVE_TYPE )
359	m_nativeDataType = hint.m_nativeDataType;	360	m_nativeDataType = hint.m_nativeDataType;
360		361
361	m_isInputOptional = hint.m_isInputOptional;	362	m_isInputOptional = hint.m_isInputOptional;
362	m_defaultInputValue = hint.m_defaultInputValue;	363	m_defaultInputValue = hint.m_defaultInputValue;
363	m_isInputMode = hint.m_isInputMode;	364	m_isInputMode = hint.m_isInputMode;
Lines 366-395 Link Here
366		367
367	sm_logger.exiting( sm_className, methodName, this );	368	sm_logger.exiting( sm_className, methodName, this );
368	}	369	}
369		370
370	/**	371	/**
371	* Returns the most effective ODI data type defined in the hint.	372	* Returns the most effective ODI data type defined in the hint.
372	* It determines the best type to use based on the native data type defined.	373	* It determines the best type to use based on the native data type defined.
373	* @param odaDataSourceId underlying ODA driver's data source id that defines	374	* @param odaDataSourceId underlying ODA driver's data source id that defines
374	* the native data type mappings	375	* the native data type mappings
375	* @param dataSetType type of data set; may be null	376	* @param dataSetType type of data set; may be null
376	* if the oda data source has only one type of data set	377	* if the oda data source has only one type of data set
377	* @return the most effective ODI data type to use	378	* @return the most effective ODI data type to use
378	*/	379	*/
379	public Class getEffectiveDataType( String odaDataSourceId, String dataSetType )	380	public Class getEffectiveDataType( String odaDataSourceId, String dataSetType )
380	{	381	{
381	return DataTypeUtil.toTypeClass(	382	return DataTypeUtil.toTypeClass(
382	getEffectiveOdaType( odaDataSourceId, dataSetType ) );	383	getEffectiveOdaType( odaDataSourceId, dataSetType ) );
383	}	384	}
384		385
385	int getEffectiveOdaType( String odaDataSourceId, String dataSetType )	386	int getEffectiveOdaType( String odaDataSourceId, String dataSetType )
386	{	387	{
387	/* The BIRT DtE ODI data type specified in a parameter hint may be based on	388	/* The BIRT DtE ODI data type specified in a parameter hint may be based on
388	* what an user manually entered in BIRT host designer, and was not necessarily	389	* what an user manually entered in BIRT host designer, and was not necessarily
389	* validated against an underlying ODA driver.	390	* validated against an underlying ODA driver.
390	* Whereas, the native data type in hint, if available, is provided by	391	* Whereas, the native data type in hint, if available, is provided by
391	* a custom ODA designer. It is thus a more reliable type to use in a retry.	392	* a custom ODA designer. It is thus a more reliable type to use in a retry.
392	* So we first try to use the native data type for the effective ODA data type.	393	* So we first try to use the native data type for the effective ODA data type.
393	*/	394	*/
394	if( getNativeDataType() != UNKNOWN_NATIVE_TYPE )	395	if( getNativeDataType() != UNKNOWN_NATIVE_TYPE )
395	{	396	{
Lines 399-408 Link Here
399	if( odaType != Types.NULL )	400	if( odaType != Types.NULL )
400	return odaType; // found valid native to oda type mapping	401	return odaType; // found valid native to oda type mapping
401	}	402	}
402		403
403	// no native data type mapping info, use the BIRT DtE ODI API data type instead	404	// no native data type mapping info, use the BIRT DtE ODI API data type instead
404	Class typeInHint = getDataType();	405	Class typeInHint = getDataType();
405	return DataTypeUtil.toOdaType( typeInHint );	406	return DataTypeUtil.toOdaType( typeInHint );
406	}	407	}
407		408
408	}	409	}

Lines 41-47 Link Here

(-)src/org/eclipse/birt/data/engine/executor/ResultClassHelper.java (-9 / +9 lines)
41	}	41	}
42		42
43	/**	43	/**
44	*	44	*
45	* @throws DataException	45	* @throws DataException
46	*/	46	*/
47	private void initIndex( ) throws DataException	47	private void initIndex( ) throws DataException
Lines 52-60 Link Here
52	{	52	{
53	Class valueClass = resultClass.getFieldValueClass( i + 1 );	53	Class valueClass = resultClass.getFieldValueClass( i + 1 );
54	assert valueClass != null;	54	assert valueClass != null;
55	if ( valueClass.isAssignableFrom( IClob.class ) )	55	if ( IClob.class.isAssignableFrom( valueClass ) )
56	clobIndexList.add( new Integer( i ) );	56	clobIndexList.add( new Integer( i ) );
57	else if ( valueClass.isAssignableFrom( IBlob.class ) )	57	else if ( IBlob.class.isAssignableFrom( valueClass ) )
58	blobIndexList.add( new Integer( i ) );;	58	blobIndexList.add( new Integer( i ) );;
59	}	59	}
60	clobIndex = toIntArray( clobIndexList );	60	clobIndex = toIntArray( clobIndexList );
Lines 64-70 Link Here
64	}	64	}
65		65
66	/**	66	/**
67	*	67	*
68	* @param integerList	68	* @param integerList
69	* @return	69	* @return
70	*/	70	*/
Lines 77-85 Link Here
77	}	77	}
78	return reArray;	78	return reArray;
79	}	79	}
80		80
81	/**	81	/**
82	*	82	*
83	* @return	83	* @return
84	*/	84	*/
85	boolean hasClobOrBlob( )	85	boolean hasClobOrBlob( )
Lines 88-94 Link Here
88	}	88	}
89		89
90	/**	90	/**
91	*	91	*
92	* @return	92	* @return
93	*/	93	*/
94	int[] getClobIndexArray( )	94	int[] getClobIndexArray( )
Lines 97-108 Link Here
97	}	97	}
98		98
99	/**	99	/**
100	*	100	*
101	* @return	101	* @return
102	*/	102	*/
103	int[] getBlobIndexArray( )	103	int[] getBlobIndexArray( )
104	{	104	{
105	return blobIndex;	105	return blobIndex;
106	}	106	}
107		107
108	}	108	}

Lines 16-22 Link Here

(-)src/org/eclipse/birt/data/engine/olap/data/util/DataType.java (-5 / +5 lines)
16	import java.util.Date;	16	import java.util.Date;
17		17
18	/**	18	/**
19	*	19	*
20	*/	20	*/
21		21
22	public class DataType	22	public class DataType
Lines 33-39 Link Here
33	public static final int BYTES_TYPE = 102;	33	public static final int BYTES_TYPE = 102;
34	public static final int SQL_DATE_TYPE = org.eclipse.birt.core.data.DataType.SQL_DATE_TYPE;	34	public static final int SQL_DATE_TYPE = org.eclipse.birt.core.data.DataType.SQL_DATE_TYPE;
35	public static final int SQL_TIME_TYPE = org.eclipse.birt.core.data.DataType.SQL_TIME_TYPE;	35	public static final int SQL_TIME_TYPE = org.eclipse.birt.core.data.DataType.SQL_TIME_TYPE;
36		36
37		37
38	private static final String[] names = {	38	private static final String[] names = {
39	"Boolean",	39	"Boolean",
Lines 87-93 Link Here
87		87
88	/**	88	/**
89	* Gets the description of a data type.	89	* Gets the description of a data type.
90	*	90	*
91	* @param typeCode	91	* @param typeCode
92	* Data type enumeration value	92	* Data type enumeration value
93	* @return Textual description of data type. "Unknown" if an undefined data	93	* @return Textual description of data type. "Unknown" if an undefined data
Lines 111-117 Link Here
111		111
112	/**	112	/**
113	* Gets the Java class used to represent the specified data type.	113	* Gets the Java class used to represent the specified data type.
114	*	114	*
115	* @return Class for the specified data type. If data type is unknown or	115	* @return Class for the specified data type. If data type is unknown or
116	* ANY, returns null.	116	* ANY, returns null.
117	*/	117	*/
Lines 132-138 Link Here
132	}	132	}
133		133
134	/**	134	/**
135	*	135	*
136	* @param objClass	136	* @param objClass
137	* @return	137	* @return
138	*/	138	*/