return op.normalize(nFlags | NORMALIZE_NORECUR);
}
}
Type leftType = m_left.getType();
Type rightType = m_right.getType();
if (leftType == null)
{
assert m_left.isConstant();
assert m_right.isConstant();
setConstantValue(Boolean.valueOf(nullPredicate(m_right.getValue() == null)));
return this;
}
if (rightType == null)
{
rightType = leftType;
m_right.setType(rightType);
}
if (!isEquivalence())
{
if (rightType == null || m_right.isConstant() && m_right.getValue() == null)
{
Operator op = createNullComparison();
op.setParent(m_parent);
if (op.getOrdinal() != ConstantOperator.ORDINAL)
{
ComparisonOperator cmpOp = (ComparisonOperator)op;
cmpOp.setLeft(m_left);
cmpOp.setRight(m_right);
}
return op.normalize(nFlags | NORMALIZE_NORECUR);
}
}
setSource(findCommonSource(m_left, m_right), nFlags);
if (leftType.isPrimitive())
{
if (rightType != null)
{
if (!rightType.isPrimitive())
{
throw new TypeMismatchException(getSymbol());
}
}
if (leftType == Primitive.ANY && m_left.isConstant() && m_right.isConstant())
{
foldObjectComparison();
return this;
}
ConversionMapper mapper = null;
BinaryDescriptor descriptor = null;
if (m_source != null)
{
mapper = m_source.getAdapter().getConversionMapper();
descriptor = mapper.getBinaryDescriptor(this);
}
if (descriptor == null)
{
m_source = null;
mapper = getConversionMapper();
descriptor = mapper.getBinaryDescriptor(this);
if (descriptor == null)
{
throw new TypeMismatchException(getSymbol());
}
}
Primitive rightPrimitive = (Primitive)rightType;
if (mapper.getType(rightPrimitive) != mapper.getType(descriptor.getRightType()))
{
setRight(new TypeConversionOperator(descriptor.getRightType(), m_right));
m_right = m_right.normalize(nFlags | NORMALIZE_NORECUR);
}
Primitive leftPrimitive = (Primitive)leftType;
if (mapper.getType(leftPrimitive) != mapper.getType(descriptor.getLeftType()))
{
if (m_right.isConstant() && Primitive.isOrderPreserved(leftPrimitive, descriptor.getLeftType()))
{
if (m_right.getValue() != null)
{
m_bConstant = false;
if (unconvertConstantComparison(leftPrimitive, rightPrimitive, m_right.getValue()))
{
if (m_bConstant)
{
return this;
}
}
else
{
setLeft(new TypeConversionOperator(descriptor.getLeftType(), m_left));
m_left = m_left.normalize(nFlags | NORMALIZE_NORECUR);
}
}
}
else
{
setLeft(new TypeConversionOperator(descriptor.getLeftType(), m_left));
m_left = m_left.normalize(nFlags | NORMALIZE_NORECUR);
}
}
if (m_left.isConstant())
{
assert m_right.isConstant();
setConstantValue(evaluate());
}
else if (m_right.isConstant())
{
if (m_left.getOrdinal() == AttributeOperator.ORDINAL)
{
AttributeOperator left = (AttributeOperator)m_left;
Converter converter = left.getConverter();
if (converter != null && (isEquivalence() ||
Primitive.isOrderPreserved(converter.getSourceType(), converter.getDestinationType())))
{
left.setType(converter.getSourceType());
left.setNoConversion(true);
m_right.setValue(converter.getInverseFunction().invoke(m_right.getValue()));
m_right.setType(converter.getSourceType());
}
}
else if (m_left.getType() == Primitive.BOOLEAN && m_right.getValue() != null)
{
switch (booleanPredicate(((Boolean)m_right.getValue()).booleanValue()))
{
case BOOL_LHS:
return m_left;
case BOOL_NOT:
NotOperator op = new NotOperator();
op.setOperand(m_left);
op.normalize(nFlags | NORMALIZE_NORECUR);
return op;
case BOOL_TRUE:
setConstantValue(Boolean.TRUE);
break;
case BOOL_FALSE:
setConstantValue(Boolean.FALSE);
break;
}
}
}
}
else
{
assert m_left.getOrdinal() == AttributeOperator.ORDINAL;
if (rightType != null)
{
if (rightType.isPrimitive() &&
(rightType != Primitive.ANY || !m_right.isConstant() ||
m_right.getValue() != null && !(m_right.getValue() instanceof OIDHolder)))
{
throw new TypeMismatchException(getSymbol());
}