Examples with TypeId org.apache.derby.iapi.types.TypeId used on opensource projects

Example 11 with TypeId

use of org.apache.derby.iapi.types.TypeId in project derby by apache.

the class ConcatenationOperatorNode method bindExpression.

/**
 * overrides BindOperatorNode.bindExpression because concatenation has
 * special requirements for parameter binding.
 *
 * @exception StandardException
 *                thrown on failure
 */
@Override
ValueNode bindExpression(FromList fromList, SubqueryList subqueryList, List<AggregateNode> aggregates) throws StandardException {
    // deal with binding operands
    leftOperand = leftOperand.bindExpression(fromList, subqueryList, aggregates);
    rightOperand = rightOperand.bindExpression(fromList, subqueryList, aggregates);
    if (leftOperand.requiresTypeFromContext()) {
        if (rightOperand.requiresTypeFromContext()) {
            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));
        if (rightOperand.getTypeId().isStringTypeId()) {
            // collation of ? operand should be picked from the context
            leftOperand.setCollationInfo(rightOperand.getTypeServices());
        }
    }
    /*
		 * 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. * If
			 * the left type is BLOB, set the parameter type to BLOB with max
			 * length. * If the left type is one of the other bit types, set the
			 * parameter type to * BIT VARYING with maximum length. * * If the
			 * left type is CLOB, set parameter type to CLOB with max length. *
			 * If the left 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 (leftOperand.getTypeId().isBitTypeId()) {
            if (leftOperand.getTypeId().isBlobTypeId())
                rightType = TypeId.getBuiltInTypeId(Types.BLOB);
            else
                rightType = TypeId.getBuiltInTypeId(Types.VARBINARY);
        } else {
            if (leftOperand.getTypeId().isClobTypeId())
                rightType = TypeId.getBuiltInTypeId(Types.CLOB);
            else
                rightType = TypeId.getBuiltInTypeId(Types.VARCHAR);
        }
        rightOperand.setType(new DataTypeDescriptor(rightType, true));
        if (leftOperand.getTypeId().isStringTypeId()) {
            // collation of ? operand should be picked from the context
            rightOperand.setCollationInfo(leftOperand.getTypeServices());
        }
    }
    /*
		 * If the left operand is not a built-in type, then generate a bound
		 * conversion tree to a built-in type.
		 */
    if (leftOperand.getTypeId().userType()) {
        leftOperand = leftOperand.genSQLJavaSQLTree();
    }
    /*
		 * If the right operand is not a built-in type, then generate a bound
		 * conversion tree to a built-in type.
		 */
    if (rightOperand.getTypeId().userType()) {
        rightOperand = rightOperand.genSQLJavaSQLTree();
    }
    /*
		 * If either the left or right operands are non-string, non-bit types,
		 * then we generate an implicit cast to VARCHAR.
		 */
    TypeCompiler tc = leftOperand.getTypeCompiler();
    if (!(leftOperand.getTypeId().isStringTypeId() || leftOperand.getTypeId().isBitTypeId())) {
        DataTypeDescriptor dtd = DataTypeDescriptor.getBuiltInDataTypeDescriptor(Types.VARCHAR, true, tc.getCastToCharWidth(leftOperand.getTypeServices()));
        leftOperand = new CastNode(leftOperand, dtd, getContextManager());
        // DERBY-2910 - Match current schema collation for implicit cast as we do for
        // explicit casts per SQL Spec 6.12 (10)
        leftOperand.setCollationUsingCompilationSchema();
        ((CastNode) leftOperand).bindCastNodeOnly();
    }
    tc = rightOperand.getTypeCompiler();
    if (!(rightOperand.getTypeId().isStringTypeId() || rightOperand.getTypeId().isBitTypeId())) {
        DataTypeDescriptor dtd = DataTypeDescriptor.getBuiltInDataTypeDescriptor(Types.VARCHAR, true, tc.getCastToCharWidth(rightOperand.getTypeServices()));
        rightOperand = new CastNode(rightOperand, dtd, getContextManager());
        // DERBY-2910 - Match current schema collation for implicit cast as we do for
        // explicit casts per SQL Spec 6.12 (10)
        rightOperand.setCollationUsingCompilationSchema();
        ((CastNode) rightOperand).bindCastNodeOnly();
    }
    /*
		 * * Set the result type of this operator based on the operands. * By
		 * convention, the left operand gets to decide the result type * of a
		 * binary operator.
		 */
    tc = leftOperand.getTypeCompiler();
    setType(resolveConcatOperation(leftOperand.getTypeServices(), rightOperand.getTypeServices()));
    /*
		 * * Make sure the maximum width set for the result doesn't exceed the
		 * result type's maximum width
		 */
    if (SanityManager.DEBUG) {
        if (getTypeServices().getMaximumWidth() > getTypeId().getMaximumMaximumWidth()) {
            SanityManager.THROWASSERT("The maximum length " + getTypeServices().getMaximumWidth() + " for the result type " + getTypeId().getSQLTypeName() + " can't be greater than it's maximum width of result's typeid" + getTypeId().getMaximumMaximumWidth());
        }
    }
    /*
		 * * Now that we know the target interface type, set it. This assumes *
		 * that both operands have the same interface type, which is a safe *
		 * assumption for the concatenation operator.
		 */
    this.setLeftRightInterfaceType(tc.interfaceName());
    // able to take advantage of concatenated literals like 'ab' || '%'.
    return this.evaluateConstantExpressions();
}

Example 12 with TypeId

use of org.apache.derby.iapi.types.TypeId in project derby by apache.

the class ConcatenationOperatorNode method resolveConcatOperation.

/**
 * Resolve a concatenation operator
 *
 * @param leftType
 *            The DataTypeDescriptor of the left operand
 * @param rightType
 *            The DataTypeDescriptor of the right operand
 *
 * @return A DataTypeDescriptor telling the result type of the concatenate
 *         operation
 *
 * @exception StandardException
 *                BinaryOperatorNotSupported Thrown when a BinaryOperator is
 *                not supported on the operand types.
 */
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();
    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();
    // 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()) {
            // operands CHAR(A) VARCHAR(B) and A+B>4000 then
            case Types.CHAR:
            // result is LONG VARCHAR
            case // operands VARCHAR(A) VARCHAR(B) and A+B>4000
            Types.VARCHAR:
                // 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()) {
            // operands CHAR FOR BIT DATA(A) VARCHAR FOR BIT
            case Types.BINARY:
            // VARCHAR FOR BIT DATA
            case // operands VARCHAR FOR BIT DATA(A) VARCHAR FOR
            Types.VARBINARY:
                // 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);
    }
    // concatenated string, an exception will be thrown at execute time.
    if (higherType.equals(TypeId.LONGVARCHAR_NAME))
        resultLength = TypeId.LONGVARCHAR_MAXWIDTH;
    else if (higherType.equals(TypeId.LONGVARBIT_NAME))
        resultLength = TypeId.LONGVARBIT_MAXWIDTH;
    /*
		 * * Result Length can't be negative
		 */
    if (SanityManager.DEBUG) {
        if (resultLength < 0) {
            SanityManager.THROWASSERT("There should not be an overflow of maximum length for any result type at this point. Overflow for BLOB/CLOB has already been handled earlier");
        }
    }
    /* The result is nullable if either side is nullable */
    nullable = leftType.isNullable() || rightType.isNullable();
    /*
		 * * Create a new DataTypeDescriptor that has the correct * type and
		 * nullability. * * It's OK to call the implementation of the
		 * DataTypeDescriptorFactory * here, because we're in the same package.
		 */
    DataTypeDescriptor returnDTD = new DataTypeDescriptor(TypeId.getBuiltInTypeId(higherType), nullable, resultLength);
    // the result will be NONE.
    if (leftType.getCollationDerivation() != rightType.getCollationDerivation() || leftType.getCollationType() != rightType.getCollationType())
        returnDTD = returnDTD.getCollatedType(returnDTD.getCollationDerivation(), StringDataValue.COLLATION_DERIVATION_NONE);
    else {
        returnDTD = returnDTD.getCollatedType(leftType.getCollationType(), leftType.getCollationDerivation());
    }
    return returnDTD;
}

Example 13 with TypeId

use of org.apache.derby.iapi.types.TypeId in project derby by apache.

the class ConditionalNode method bindExpression.

/**
 * Bind this expression.  This means binding the sub-expressions,
 * as well as figuring out what the return type is for this expression.
 *
 * @param fromList		The FROM list for the query this
 *				expression is in, for binding columns.
 * @param subqueryList		The subquery list being built as we find SubqueryNodes
 * @param aggregates        The aggregate list being built as we find AggregateNodes
 *
 * @return	The new top of the expression tree.
 *
 * @exception StandardException		Thrown on error
 */
@Override
ValueNode bindExpression(FromList fromList, SubqueryList subqueryList, List<AggregateNode> aggregates) throws StandardException {
    CompilerContext cc = getCompilerContext();
    int previousReliability = orReliability(CompilerContext.CONDITIONAL_RESTRICTION);
    ValueNodeList caseOperandParameters = bindCaseOperand(cc, fromList, subqueryList, aggregates);
    testConditions.bindExpression(fromList, subqueryList, aggregates);
    // parameter), find out which type best describes it.
    if (caseOperandParameters != null) {
        // when testConditions was bound.
        for (ValueNode vn : caseOperandParameters) {
            // Check that this parameter is comparable to all the other
            // parameters in the list. This indirectly checks whether
            // all when operands have compatible types.
            caseOperandParameters.comparable(vn);
            // Replace the dummy parameter node with the actual case
            // operand.
            testConditions.accept(new ReplaceNodeVisitor(vn, caseOperand));
        }
        // Finally, after we have determined that all the when operands
        // are compatible, and we have reinserted the case operand into
        // the tree, set the type of the case operand to the dominant
        // type of all the when operands.
        caseOperand.setType(caseOperandParameters.getDominantTypeServices());
    }
    thenElseList.bindExpression(fromList, subqueryList, aggregates);
    // Find the type of the first typed value in thenElseList and cast
    // all untyped NULL values to that type. We don't need to find the
    // dominant type here, since a top-level cast to that type will be
    // added later, if necessary.
    DataTypeDescriptor nullType = thenElseList.getTypeServices();
    if (nullType == null) {
        // an error.
        throw StandardException.newException(SQLState.LANG_ALL_RESULT_EXPRESSIONS_UNTYPED);
    } else {
        recastNullNodes(nullType, fromList, subqueryList, aggregates);
    }
    // Set the result type of this conditional to be the dominant type
    // of the result expressions.
    setType(thenElseList.getDominantTypeServices());
    /* testCondition must be a boolean expression.
		 * If it is a ? parameter on the left, then set type to boolean,
		 * otherwise verify that the result type is boolean.
		 */
    testConditions.setParameterDescriptor(new DataTypeDescriptor(TypeId.BOOLEAN_ID, true));
    for (ValueNode testCondition : testConditions) {
        if (!testCondition.getTypeServices().getTypeId().equals(TypeId.BOOLEAN_ID)) {
            throw StandardException.newException(SQLState.LANG_CONDITIONAL_NON_BOOLEAN);
        }
    }
    // Set the type of the parameters.
    thenElseList.setParameterDescriptor(getTypeServices());
    /* The then and else expressions must be type compatible */
    ClassInspector cu = getClassFactory().getClassInspector();
    /*
		** If it is comparable, then we are ok.  Note that we
		** could in fact allow any expressions that are convertible()
		** since we are going to generate a cast node, but that might
		** be confusing to users...
		*/
    for (ValueNode expr : thenElseList) {
        DataTypeDescriptor dtd = expr.getTypeServices();
        String javaTypeName = dtd.getTypeId().getCorrespondingJavaTypeName();
        String resultJavaTypeName = getTypeId().getCorrespondingJavaTypeName();
        if (!dtd.comparable(getTypeServices(), false, getClassFactory()) && !cu.assignableTo(javaTypeName, resultJavaTypeName) && !cu.assignableTo(resultJavaTypeName, javaTypeName)) {
            throw StandardException.newException(SQLState.LANG_NOT_TYPE_COMPATIBLE, dtd.getTypeId().getSQLTypeName(), getTypeId().getSQLTypeName());
        }
    }
    // The result is nullable if and only if at least one of the result
    // expressions is nullable (DERBY-6567).
    setNullability(thenElseList.isNullable());
    /*
		** Generate a CastNode if necessary and
		** stick it over the original expression
		*/
    TypeId condTypeId = getTypeId();
    for (int i = 0; i < thenElseList.size(); i++) {
        ValueNode expr = thenElseList.elementAt(i);
        if (expr.getTypeId().typePrecedence() != condTypeId.typePrecedence()) {
            // Cast to dominant type.
            ValueNode cast = new CastNode(expr, getTypeServices(), getContextManager());
            cast = cast.bindExpression(fromList, subqueryList, aggregates);
            thenElseList.setElementAt(cast, i);
        }
    }
    cc.setReliability(previousReliability);
    return this;
}

Example 14 with TypeId

use of org.apache.derby.iapi.types.TypeId in project derby by apache.

the class GroupByColumn method bindExpression.

/**
 * Bind this grouping column.
 *
 * @param fromList			The FROM list to use for binding
 * @param subqueryList		The SubqueryList we are building as we hit
 *							SubqueryNodes.
 * @param aggregates        The aggregate list we build as we hit
 *							AggregateNodes.
 *
 * @exception StandardException	Thrown on error
 */
void bindExpression(FromList fromList, SubqueryList subqueryList, List<AggregateNode> aggregates) throws StandardException {
    /* Bind the ColumnReference to the FromList */
    int previousReliability = orReliability(CompilerContext.GROUP_BY_RESTRICTION);
    columnExpression = columnExpression.bindExpression(fromList, subqueryList, aggregates);
    getCompilerContext().setReliability(previousReliability);
    // Verify that we can group on the column
    if (columnExpression.isParameterNode()) {
        throw StandardException.newException(SQLState.LANG_INVALID_COL_REF_GROUPED_SELECT_LIST, columnExpression);
    }
    /*
		 * Do not check to see if we can map user types
		 * 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());
    }
}

Example 15 with TypeId

use of org.apache.derby.iapi.types.TypeId in project derby by apache.

the class BinaryRelationalOperatorNode method implicitVarcharComparison.

/**
 * Return whether or not this binary relational predicate requires an implicit
 * (var)char conversion.  This is important when considering
 * hash join since this type of equality predicate is not currently
 * supported for a hash join.
 *
 * @return	Whether or not an implicit (var)char conversion is required for
 *			this binary relational operator.
 *
 * @exception StandardException		Thrown on error
 */
private boolean implicitVarcharComparison() throws StandardException {
    TypeId leftType = leftOperand.getTypeId();
    TypeId rightType = rightOperand.getTypeId();
    if (leftType.isStringTypeId() && !rightType.isStringTypeId())
        return true;
    if (rightType.isStringTypeId() && (!leftType.isStringTypeId()))
        return true;
    return false;
}