private String getDataText(Object element) {
   if (element != null) {
     if (expectedColumnDataType == DataType.SQL_DATE_TYPE && element instanceof Date) {
       formatter.applyPattern("yyyy-MM-dd"); // $NON-NLS-1$
       return formatter.format((Date) element);
     } else if (expectedColumnDataType == DataType.SQL_TIME_TYPE && element instanceof Date) {
       formatter.applyPattern("HH:mm:ss.SSS"); // $NON-NLS-1$
       return formatter.format((Date) element);
     } else if (expectedColumnDataType == DataType.DATE_TYPE && element instanceof Date) {
       formatter.applyPattern("yyyy-MM-dd HH:mm:ss.SSS"); // $NON-NLS-1$
       return formatter.format((Date) element);
     }
     // Because of fixed Timestamp format problem(T60058),add DataTypeUtil.toString(element );
     // But this will make nunmber format has "," ,such as 10000 to be 10,000
     // In SelectValueDialog ,it call DataTypeUtil.toLocaleNeutralString( element )
     // So add follow code to call DataTypeUtil.toLocaleNeutralString( element )
     else if (element instanceof Number) {
       try {
         return DataTypeUtil.toLocaleNeutralString(element);
       } catch (BirtException e) {
         return String.valueOf(element);
       }
     } else {
       try {
         return DataTypeUtil.toString(element);
       } catch (BirtException e) {
         return String.valueOf(element);
       }
     }
   }
   return null;
 }
 /**
  * set parameter choice value. The string value is in English locale, and needs to be parsed back
  * into object value based on the data type.
  *
  * @param value the string value for the object
  * @param type the parameter data type
  */
 public void setValue(String value, int type) {
   try {
     switch (type) {
       case IScalarParameterDefn.TYPE_BOOLEAN:
         this.value = DataTypeUtil.toBoolean(value);
         break;
       case IScalarParameterDefn.TYPE_DATE_TIME:
         this.value = DataTypeUtil.toDate(value);
         break;
       case IScalarParameterDefn.TYPE_DECIMAL:
         this.value = DataTypeUtil.toBigDecimal(value);
         break;
       case IScalarParameterDefn.TYPE_FLOAT:
         this.value = DataTypeUtil.toDouble(value);
         break;
       case IScalarParameterDefn.TYPE_INTEGER:
         this.value = DataTypeUtil.toInteger(value);
         break;
       case IScalarParameterDefn.TYPE_DATE:
         this.value = DataTypeUtil.toSqlDate(value);
         break;
       case IScalarParameterDefn.TYPE_TIME:
         this.value = DataTypeUtil.toSqlTime(value);
         break;
       case IScalarParameterDefn.TYPE_STRING:
       default:
         this.value = DataTypeUtil.toString(value);
         break;
     }
   } catch (BirtException e) {
     log.log(Level.SEVERE, e.getLocalizedMessage(), e);
     this.value = null;
   }
 }
Exemple #3
0
  /**
   * @param value
   * @param N
   * @throws DataException
   */
  private void populateValueListAndRowIdList(Object value, int N) throws DataException {
    assert N >= 0;
    int activeCount = N < this.firstPassRowNumberCounter ? N : this.firstPassRowNumberCounter;
    for (int i = 0; i < activeCount; i++) {
      if (valueList.get(i) == null) {
        valueList.set(i, value);
        rowIdList.set(i, Integer.valueOf(firstPassRowNumberCounter));
        break;
      } else {
        Object result = this.doCompare(value, valueList.get(i));

        try {
          // filter in
          if (DataTypeUtil.toBoolean(result).booleanValue() == true) {
            for (int j = activeCount - 1; j > i; j--) {
              valueList.set(j, valueList.get(j - 1));
              rowIdList.set(j, rowIdList.get(j - 1));
            }
            valueList.set(i, value);
            rowIdList.set(i, Integer.valueOf(firstPassRowNumberCounter));
            break;
          }
        } catch (BirtException e) {
          throw DataException.wrap(e);
        }
      }
    }
  }
Exemple #4
0
 /*
  * (non-Javadoc)
  *
  * @see org.eclipse.birt.data.engine.api.aggregation.ICalculator#getTypedObject(java.lang.Object)
  */
 public Object getTypedObject(Object obj) throws DataException {
   try {
     return DataTypeUtil.toDouble(obj);
   } catch (BirtException e) {
     throw DataException.wrap(e);
   }
 }
Exemple #5
0
  private IResultClass mergeResultHint(List modelResultHints, IResultClass meta) {
    if (modelResultHints == null || modelResultHints.isEmpty()) return meta;
    IResultClass newResultClass;
    try {
      newResultClass = copyResultClass(meta);
    } catch (Exception ex) {
      return meta;
    }
    boolean changed = false;
    int count = newResultClass.getFieldCount();
    try {
      for (int i = 1; i <= count; i++) {
        String fieldName = newResultClass.getFieldName(i);
        Class odaType = newResultClass.getFieldMetaData(i).getDataType();
        for (int j = 0; j < modelResultHints.size(); j++) {
          if (((IColumnDefinition) modelResultHints.get(j)).getColumnName().equals(fieldName)) {
            int apiType = ((IColumnDefinition) modelResultHints.get(j)).getDataType();
            if (apiType > 0 && DataTypeUtil.toApiDataType(odaType) != apiType) {
              newResultClass.getFieldMetaData(i).setDataType(DataType.getClass(apiType));
              changed = true;
            }
            break;
          }
        }
      }
    } catch (Exception ex) {
    }

    if (changed) return newResultClass;
    else return meta;
  }
Exemple #6
0
 /**
  * convert the String value to Object according to its data type.
  *
  * @param inputValue
  * @param type
  * @return
  * @throws DataException
  */
 private static Object convertToValue(Object inputValue, Class typeClass) throws DataException {
   try {
     return DataTypeUtil.convert(inputValue, typeClass);
   } catch (Exception ex) {
     throw new DataException(
         ResourceConstants.CANNOT_CONVERT_PARAMETER_TYPE,
         ex,
         new Object[] {inputValue, typeClass});
   }
 }
Exemple #7
0
  /**
   * Evaluate the given value
   *
   * @param value
   * @param n
   * @return
   * @throws DataException
   */
  public boolean evaluate(ScriptContext cx, Scriptable scope, DataSetRuntime dataSet)
      throws DataException {
    if (filterPassController.getForceReset()) {
      doReset();
      filterPassController.setForceReset(false);
    }

    if (N == -1) {
      // Create a new evaluator
      // Evaluate N (which is operand1) at this time
      Object n_object = null;
      try {
        n_object = ExprEvaluateUtil.evaluateRawExpression2(n_expr, scope, cx, dataSet);
      } catch (BirtException e1) {
        throw DataException.wrap(e1);
      }

      double n_value = -1;
      try {
        n_value = DataTypeUtil.toDouble(n_object).doubleValue();
      } catch (BirtException e) {
        // conversion error
        throw new DataException(ResourceConstants.INVALID_TOP_BOTTOM_ARGUMENT, e);
      }

      // First time; calculate N based on updated row count
      if (n_percent) {
        if (n_value < 0 || n_value > 100)
          throw new DataException(ResourceConstants.INVALID_TOP_BOTTOM_PERCENT_ARGUMENT);
        N = (int) Math.round(n_value / 100 * filterPassController.getRowCount());
      } else {
        if (n_value < 0) throw new DataException(ResourceConstants.INVALID_TOP_BOTTOM_N_ARGUMENT);
        N = (int) n_value;
      }
    }

    // Evaluate operand expression
    Object value =
        ScriptEvalUtil.evalExpr(op_expr, cx.newContext(scope), ScriptExpression.defaultID, 0);

    if (filterPassController.getPassLevel() == FilterPassController.FIRST_PASS) {
      return doFirstPass(value);
    } else if (filterPassController.getPassLevel() == FilterPassController.SECOND_PASS) {
      return doSecondPass();
    }
    return false;
  }
 /**
  * @param fieldType
  * @return
  */
 private Object createNullValueReplacer(Object o) {
   switch (DataTypeUtil.toApiDataType(o.getClass())) {
     case DataType.DATE_TYPE:
       return new java.util.Date(nullTime);
     case DataType.SQL_DATE_TYPE:
       return new java.sql.Date(nullTime);
     case DataType.SQL_TIME_TYPE:
       return new Time(nullTime);
     case DataType.BOOLEAN_TYPE:
       return Boolean.FALSE;
     case DataType.DECIMAL_TYPE:
       return new BigDecimal(0);
     case DataType.DOUBLE_TYPE:
       return new Double(0);
     case DataType.INTEGER_TYPE:
       return Integer.valueOf(0);
     case DataType.STRING_TYPE:
       return "";
     default:
       return "";
   }
 }
Exemple #9
0
 /*
  * @see org.eclipse.birt.data.engine.api.IResultIterator#getBytes(java.lang.String)
  */
 public byte[] getBytes(String name) throws BirtException {
   return DataTypeUtil.toBytes(getValue(name));
 }
Exemple #10
0
 /*
  * @see org.eclipse.birt.data.engine.api.IResultIterator#getBlob(java.lang.String)
  */
 public Blob getBlob(String name) throws BirtException {
   return DataTypeUtil.toBlob(getValue(name));
 }
Exemple #11
0
 /*
  * @see org.eclipse.birt.data.engine.api.IResultIterator#getDate(java.lang.String)
  */
 public Date getDate(String name) throws BirtException {
   return DataTypeUtil.toDate(getValue(name));
 }
Exemple #12
0
 /*
  * @see org.eclipse.birt.data.engine.api.IResultIterator#getBigDecimal(java.lang.String)
  */
 public BigDecimal getBigDecimal(String name) throws BirtException {
   return DataTypeUtil.toBigDecimal(getValue(name));
 }
Exemple #13
0
 /*
  * @see org.eclipse.birt.data.engine.api.IResultIterator#getString(java.lang.String)
  */
 public String getString(String name) throws BirtException {
   return DataTypeUtil.toString(getValue(name));
 }
Exemple #14
0
 /*
  * @see org.eclipse.birt.data.engine.api.IResultIterator#getInteger(java.lang.String)
  */
 public Integer getInteger(String name) throws BirtException {
   return DataTypeUtil.toInteger(getValue(name));
 }
Exemple #15
0
 /*
  * @see org.eclipse.birt.data.engine.api.IResultIterator#getBoolean(java.lang.String)
  */
 public Boolean getBoolean(String name) throws BirtException {
   return DataTypeUtil.toBoolean(getValue(name));
 }