Package org.apache.derby.iapi.types

Examples of org.apache.derby.iapi.types.TypeId


                        int judgeUserJDBCTypeId)
                    throws StandardException
  {
    DataValueDescriptor judge;
    if (judgeUserJDBCTypeId == -1)
      judge =  new TypeId(judgeTypeFormatId, null).getNull();
    else
      judge =  new TypeId(judgeTypeFormatId, new UserDefinedTypeIdImpl()).getNull();

    DataValueDescriptor maxVal = v1;
    if (v2 != null && judge.greaterThan(v2, maxVal).equals(true))
      maxVal = v2;
    if (v3 != null && judge.greaterThan(v3, maxVal).equals(true))
View Full Code Here


     * to built-in types.  The ability to do so does
     * not mean that ordering will work.  In fact,
     * as of version 2.0, ordering does not work on
     * user types.
     */
    TypeId ctid = columnExpression.getTypeId();
    if (! ctid.orderable(getClassFactory()))
    {
      throw StandardException.newException(SQLState.LANG_COLUMN_NOT_ORDERABLE_DURING_EXECUTION,
              ctid.getSQLTypeName());
    }
  }
View Full Code Here

    /*
    ** Generate a CastNode if necessary and
    ** stick it over the original expression
    */
    TypeId condTypeId = getTypeId();
    TypeId thenTypeId = ((ValueNode) thenElseList.elementAt(0)).getTypeId();
    TypeId elseTypeId = ((ValueNode) thenElseList.elementAt(1)).getTypeId();

    /* Need to generate conversion if thenExpr or elseExpr is not of
     * dominant type.  (At least 1 of them must be of the dominant type.)
     */
    if (thenTypeId.typePrecedence() != condTypeId.typePrecedence())
    {
      ValueNode cast = (ValueNode) getNodeFactory().getNode(
                C_NodeTypes.CAST_NODE,
                thenElseList.elementAt(0),
                dataTypeServices,  // cast to dominant type
                getContextManager());
      cast = cast.bindExpression(fromList,
                      subqueryList,
                      aggregateVector);
     
      thenElseList.setElementAt(cast, 0);
    }

    else if (elseTypeId.typePrecedence() != condTypeId.typePrecedence())
    {
      ValueNode cast = (ValueNode) getNodeFactory().getNode(
                C_NodeTypes.CAST_NODE,
                thenElseList.elementAt(1),
                dataTypeServices,  // cast to dominant type
View Full Code Here

    /*
    ** Generate a CastNode if necessary and
    ** stick it over the original expression
    */
    TypeId condTypeId = getTypeId();
    TypeId thenTypeId = ((ValueNode) thenElseList.elementAt(0)).getTypeId();
    TypeId elseTypeId = ((ValueNode) thenElseList.elementAt(1)).getTypeId();

    /* Need to generate conversion if thenExpr or elseExpr is not of
     * dominant type.  (At least 1 of them must be of the dominant type.)
     */
    if (thenTypeId.typePrecedence() != condTypeId.typePrecedence())
    {
      ValueNode cast = (ValueNode) getNodeFactory().getNode(
                C_NodeTypes.CAST_NODE,
                thenElseList.elementAt(0),
                dataTypeServices,  // cast to dominant type
                getContextManager());
      cast = cast.bindExpression(fromList,
                      subqueryList,
                      aggregateVector);
     
      thenElseList.setElementAt(cast, 0);
    }

    else if (elseTypeId.typePrecedence() != condTypeId.typePrecedence())
    {
      ValueNode cast = (ValueNode) getNodeFactory().getNode(
                C_NodeTypes.CAST_NODE,
                thenElseList.elementAt(1),
                dataTypeServices,  // cast to dominant type
View Full Code Here

      {
        throw StandardException.newException(SQLState.LANG_BINARY_OPERANDS_BOTH_PARMS,
                                  operator);
      }

      TypeId   leftType;

      /*
      ** A ? on the left gets its type from the right.  There are eight
      ** legal types for the concatenation operator: CHAR, VARCHAR,
      ** LONG VARCHAR, CLOB, BIT, BIT VARYING, LONG BIT VARYING, and BLOB.
      ** If the right type is BLOB, set the parameter type to BLOB with max length.
      ** If the right type is one of the other bit types, set the parameter type to
      ** BIT VARYING with maximum length.
      **
      ** If the right type is CLOB, set parameter type to CLOB with max length.
      ** If the right type is anything else, set it to VARCHAR with
      ** maximum length.  We count on the resolveConcatOperation method to
      ** catch an illegal type.
      **
      ** NOTE: When I added the long types, I could have changed the
      ** resulting parameter types to LONG VARCHAR and LONG BIT VARYING,
      ** but they were already VARCHAR and BIT VARYING, and it wasn't
      ** clear to me what effect it would have to change it. -  Jeff
      */
      if (rightOperand.getTypeId().isBitTypeId())
      {
        if (rightOperand.getTypeId().isBlobTypeId())
          leftType = TypeId.getBuiltInTypeId(Types.BLOB);
        else
          leftType = TypeId.getBuiltInTypeId(Types.VARBINARY);
      }
      else
      {
        if (rightOperand.getTypeId().isClobTypeId())
          leftType = TypeId.getBuiltInTypeId(Types.CLOB);
        else
          leftType = TypeId.getBuiltInTypeId(Types.VARCHAR);
      }

    leftOperand.setType(new DataTypeDescriptor(leftType, true));
    }

    /*
      Is there a ? parameter on the right?
    */
    if (rightOperand.requiresTypeFromContext())
    {
      TypeId   rightType;

      /*
      ** A ? on the right gets its type from the left.  There are eight
      ** legal types for the concatenation operator: CHAR, VARCHAR,
      ** LONG VARCHAR, CLOB, BIT, BIT VARYING, LONG BIT VARYING, and BLOB.
View Full Code Here

  private DataTypeDescriptor resolveConcatOperation(
                DataTypeDescriptor leftType,
                DataTypeDescriptor rightType
              ) throws StandardException
  {
    TypeId  leftTypeId;
    TypeId  rightTypeId;
    String  higherType;
    int          resultLength;
    boolean        nullable;

    leftTypeId = leftType.getTypeId();
    rightTypeId = rightType.getTypeId();

    /*
    ** Check the right type to be sure it's a concatable.  By convention,
    ** we call this method off the TypeId of the left operand, so if
    ** we get here, we know the left operand is a concatable.
    */
    /*
    ** Make sure we haven't been given a char and a
    ** bit to concatenate.
    */

    if (!leftTypeId.isConcatableTypeId()
      || !rightTypeId.isConcatableTypeId()
      || (rightTypeId.isBitTypeId() && leftTypeId.isStringTypeId())
      || (leftTypeId.isBitTypeId() && rightTypeId.isStringTypeId()))
        throw StandardException.newException(SQLState.LANG_DB2_FUNCTION_INCOMPATIBLE, "||", "FUNCTION");

    /*
    ** The types aren't the same.  The result of the operation is the
    ** type of higher precedence.
    */
   
    higherType = (leftTypeId.typePrecedence() >=
                  rightTypeId.typePrecedence()) ?
        leftType.getTypeName() : rightType.getTypeName();

    /* Get the length of the result */
    resultLength = leftType.getMaximumWidth() +
             rightType.getMaximumWidth();

    /*
    ** Use following chart to handle overflow
    ** operands CHAR(A) CHAR(B) and A+B<255 then result is CHAR(A+B)
    ** operands CHAR FOR BIT DATA(A) CHAR FOR BIT DATA(B) and A+B<255 then result is CHAR FOR BIT DATA(A+B)
    **
    ** operands CHAR(A) CHAR(B) and A+B>254 then result is VARCHAR(A+B)
    ** operands CHAR FOR BIT DATA(A) CHAR FOR BIT DATA(B) and A+B>254 then result is VARCHAR FOR BIT DATA(A+B)
    **
    ** operands CHAR(A) VARCHAR(B) and A+B<4001 then result is VARCHAR(A+B)
    ** operands CHAR FOR BIT DATA(A) VARCHAR FOR BIT DATA(B) and A+B<4001 then result is VARCHAR FOR BIT DATA(A+B)
    **
    ** operands CHAR(A) VARCHAR(B) and A+B>4000 then result is LONG VARCHAR
    ** operands CHAR FOR BIT DATA(A) VARCHAR FOR BIT DATA(B) and A+B>4000 then result is LONG VARCHAR FOR BIT DATA
    **
    ** operands CHAR(A) LONG VARCHAR then result is LONG VARCHAR
    ** operands CHAR FOR BIT DATA(A) LONG VARCHAR FOR BIT DATA then result is LONG VARCHAR FOR BIT DATA
    **
    ** operands VARCHAR(A) VARCHAR(B) and A+B<4001 then result is VARCHAR(A+B)
    ** operands VARCHAR FOR BIT DATA(A) VARCHAR FOR BIT DATA(B) and A+B<4001 then result is VARCHAR FOR BIT DATA(A+B)
    **
    ** operands VARCHAR(A) VARCHAR(B) and A+B>4000 then result is LONG VARCHAR
    ** operands VARCHAR FOR BIT DATA(A) VARCHAR FOR BIT DATA(B) and A+B>4000 then result is LONG VARCHAR FOR BIT DATA
    **
    ** operands VARCHAR(A) LONG VARCHAR then result is LONG VARCHAR
    ** operands VARCHAR FOR BIT DATA(A) LONG VARCHAR FOR BIT DATA then result is LONG VARCHAR FOR BIT DATA
    **
    ** operands LONG VARCHAR, LONG VARCHAR then result is LONG VARCHAR
    ** operands LONG VARCHAR FOR BIT DATA, LONG VARCHAR FOR BIT DATA then result is LONG VARCHAR FOR BIT DATA
    **
    ** operands CLOB(A), CHAR(B) then result is CLOB(MIN(A+B,2G))
    ** operands CLOB(A), VARCHAR(B) then result is CLOB(MIN(A+B,2G))
    ** operands CLOB(A), LONG VARCHAR then result is CLOB(MIN(A+32K,2G))
    ** operands CLOB(A), CLOB(B) then result is CLOB(MIN(A+B,2G))
    **
    ** operands BLOB(A), CHAR FOR BIT DATA(B) then result is BLOB(MIN(A+B,2G))
    ** operands BLOB(A), VARCHAR FOR BIT DATA(B) then result is BLOB(MIN(A+B,2G))
    ** operands BLOB(A), LONG VARCHAR FOR BIT DATA then result is BLOB(MIN(A+32K,2G))
    ** operands BLOB(A), BLOB(B) then result is BLOB(MIN(A+B,2G))
    **
    ** operands CHAR(A)/VARCHAR(A)/LONGVARCHAR, LONGVARCHAR and "concatenated string length">32700 does not cause automatic escalation
    ** to LOB for compatibility with previous releases. Any such cases would result in an error at runtime
    **
    */
    //in the following code, I can assume that left and right operands both will be either char kind
    //of datatypes or they will be both binary kind of datatypes. That's because operand datatypes
    //mismatch has already been handled earlier
    if (leftTypeId.getJDBCTypeId() == Types.CHAR || leftTypeId.getJDBCTypeId() == Types.BINARY)
    {
      switch (rightTypeId.getJDBCTypeId())
      {
        case Types.CHAR:
        case Types.BINARY:
          if (resultLength > Limits.DB2_CHAR_MAXWIDTH) {
            if (rightTypeId.getJDBCTypeId() == Types.CHAR)
                //operands CHAR(A) CHAR(B) and A+B>254 then result is VARCHAR(A+B)
                higherType = TypeId.VARCHAR_NAME;
            else
                //operands CHAR FOR BIT DATA(A) CHAR FOR BIT DATA(B) and A+B>254 then result is VARCHAR FOR BIT DATA(A+B)
                higherType = TypeId.VARBIT_NAME;
          }
          break;

        case Types.VARCHAR:
        case Types.VARBINARY:
          if (resultLength > Limits.DB2_CONCAT_VARCHAR_LENGTH) {
            if (rightTypeId.getJDBCTypeId() == Types.VARCHAR)
                //operands CHAR(A) VARCHAR(B) and A+B>4000 then result is LONG VARCHAR
                higherType = TypeId.LONGVARCHAR_NAME;
            else
                //operands CHAR FOR BIT DATA(A) VARCHAR FOR BIT DATA(B) and A+B>4000 then result is LONG VARCHAR FOR BIT DATA
                higherType = TypeId.LONGVARBIT_NAME;
          }
          break;

        case Types.CLOB:
        case Types.BLOB:
          //operands CHAR(A), CLOB(B) then result is CLOB(MIN(A+B,2G))
          //operands CHAR FOR BIT DATA(A), BLOB(B) then result is BLOB(MIN(A+B,2G))
          resultLength = clobBlobHandling(rightType, leftType);
          break;
      }
    } else if (leftTypeId.getJDBCTypeId() == Types.VARCHAR) {
      switch (rightTypeId.getJDBCTypeId())
      {
        case Types.CHAR: //operands CHAR(A) VARCHAR(B) and A+B>4000 then result is LONG VARCHAR
        case Types.VARCHAR: //operands VARCHAR(A) VARCHAR(B) and A+B>4000 then result is LONG VARCHAR
          if (resultLength > Limits.DB2_CONCAT_VARCHAR_LENGTH)
            higherType = TypeId.LONGVARCHAR_NAME;
          break;

        case Types.CLOB:
          //operands VARCHAR(A), CLOB(B) then result is CLOB(MIN(A+B,2G))
          resultLength = clobBlobHandling(rightType, leftType);
          break;
      }
    } else if (leftTypeId.getJDBCTypeId() == Types.VARBINARY) {
      switch (rightTypeId.getJDBCTypeId())
      {
        case Types.BINARY: //operands CHAR FOR BIT DATA(A) VARCHAR FOR BIT DATA(B) and A+B>4000 then result is LONG VARCHAR FOR BIT DATA
        case Types.VARBINARY://operands VARCHAR FOR BIT DATA(A) VARCHAR FOR BIT DATA(B) and A+B>4000 then result is LONG VARCHAR FOR BIT DATA
          if (resultLength > Limits.DB2_CONCAT_VARCHAR_LENGTH)
            higherType = TypeId.LONGVARBIT_NAME;
          break;

        case Types.BLOB:
          //operands VARCHAR FOR BIT DATA(A), BLOB(B) then result is BLOB(MIN(A+B,2G))
          resultLength = clobBlobHandling(rightType, leftType);
          break;
      }
    } else if (leftTypeId.getJDBCTypeId() == Types.CLOB || leftTypeId.getJDBCTypeId() == Types.BLOB) {
      //operands CLOB(A), CHAR(B) then result is CLOB(MIN(A+B,2G))
      //operands CLOB(A), VARCHAR(B) then result is CLOB(MIN(A+B,2G))
      //operands CLOB(A), LONG VARCHAR then result is CLOB(MIN(A+32K,2G))
      //operands CLOB(A), CLOB(B) then result is CLOB(MIN(A+B,2G))
      //operands BLOB(A), CHAR FOR BIT DATA(B) then result is BLOB(MIN(A+B,2G))
      //operands BLOB(A), VARCHAR FOR BIT DATA(B) then result is BLOB(MIN(A+B,2G))
      //operands BLOB(A), LONG VARCHAR FOR BIT DATA then result is BLOB(MIN(A+32K,2G))
      //operands BLOB(A), BLOB(B) then result is BLOB(MIN(A+B,2G))
      resultLength = clobBlobHandling(leftType, rightType);
    } else if (rightTypeId.getJDBCTypeId() == Types.CLOB || rightTypeId.getJDBCTypeId() == Types.BLOB) {
      //operands LONG VARCHAR, CLOB(A) then result is CLOB(MIN(A+32K,2G))
      //operands LONG VARCHAR FOR BIT DATA, BLOB(A) then result is BLOB(MIN(A+32K,2G))
      resultLength = clobBlobHandling(rightType, leftType);
    }

View Full Code Here

     * we generate a cast above the reciever to force preprocess to
     * not attempt any of the > <= optimizations since there is no
     * way to determine the 'next' character for the <= operand.
     */

    TypeId leftTypeId = leftOperand.getTypeId();
    TypeId receiverTypeId = receiver.getTypeId();

    if (receiverTypeId.isNationalStringTypeId() && ! leftTypeId.isNationalStringTypeId())
    {
      receiver = castArgToNationalString(receiver, receiverTC, receiverTypeId);
    }
    else if (leftTypeId.isNationalStringTypeId() && ! receiverTypeId.isNationalStringTypeId())
    {
      leftOperand = castArgToNationalString(leftOperand, leftTC, leftTypeId);
    }

    finishBindExpr();
View Full Code Here

   */

  public void bindComparisonOperator()
      throws StandardException
  {
    TypeId  receiverType = receiver.getTypeId();
    TypeId  leftType = leftOperand.getTypeId();

    /*
    ** Check the type of the operands - this function is allowed only on
    ** string types.
    */

    if ( ! receiverType.isStringTypeId())
    {
      throw StandardException.newException(SQLState.LANG_LIKE_BAD_TYPE,
                        receiverType.getSQLTypeName());
    }

    if (! leftType.isStringTypeId())
    {
      throw StandardException.newException(SQLState.LANG_LIKE_BAD_TYPE,
                        leftType.getSQLTypeName());
    }

    if (rightOperand != null && ! rightOperand.getTypeId().isStringTypeId())
    {
      throw StandardException.newException(SQLState.LANG_LIKE_BAD_TYPE,
View Full Code Here

                    TypeDescriptor.MAXIMUM_WIDTH_UNKNOWN));
    }
    else
    {
      Integer maxWidth = null;
      TypeId  typeId = null;

            if( arg1 instanceof DataValueDescriptor)
                dvd = (DataValueDescriptor) arg1;
      if (arg1 instanceof Date
                || (dvd != null && dvd.getTypeFormatId() == StoredFormatIds.SQL_DATE_ID))
View Full Code Here

  {
        if( value instanceof DataValueDescriptor)
            return ((DataValueDescriptor) value).getClone();
       
    DataValueFactory      dvf = getDataValueFactory();
    TypeId      typeID = getTypeId();
    String            typeName = typeID.getSQLTypeName();

    if ( typeName.equals( TypeId.DATE_NAME ) )
    {
      return  new SQLDate((Date) value);
    }
View Full Code Here

TOP

Related Classes of org.apache.derby.iapi.types.TypeId

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.