Create condition of compare operator.

@param compareRightValue right value of compare operator
@param column column
@return condition
7321
public static Optional<Condition> createCompareCondition(final PredicateCompareRightValue compareRightValue, final Column column) {
        return compareRightValue.getExpression() instanceof SimpleExpressionSegment
                ? Optional.of(new Condition(column, ((SimpleExpressionSegment) compareRightValue.getExpression()).getSQLExpression())) : Optional.<Condition>absent();
    }
147683
private static Optional<EvaluatedCondition> evaluateCondition(Condition condition, ValueType type, Comparable value) {
    Comparable threshold = getThreshold(condition, type);

    if (reachThreshold(value, threshold, condition)) {
      return of(new EvaluatedCondition(condition, EvaluationStatus.ERROR, value.toString()));
    }
    return Optional.empty();
  }
407347
final boolean casRight(Index<K,V> cmp, Index<K,V> val) {
            return U.compareAndSwapObject(this, RIGHT, cmp, val);
        }
1206642
private boolean valueEquals(V leftValue, V rightValue) {
        if (leftValue == rightValue) {
            return true;
        }
        if (leftValue == null || rightValue == null) {
            return false;
        }
        return leftValue.equals(rightValue);
    }
1057772
public Where<T, ID> gt(String columnName, Object value) throws SQLException {
		addClause(new SimpleComparison(columnName, findColumnFieldType(columnName), value,
				SimpleComparison.GREATER_THAN_OPERATION));
		return this;
	}
797253
@Override
    public BooleanExpression eq(Expression<? super T> right) {
        return Expressions.booleanOperation(SpatialOps.EQUALS, mixin, right);
    }
463025
@Deprecated
    public static Criteria create(String left, String operator, String right) {
        Criteria criteria = new Criteria(ValueNode.toValueNode(left));
        criteria.criteriaType = RelationalOperator.fromString(operator);
        criteria.right = ValueNode.toValueNode(right);
        return criteria;
    }
766587
@Override
	public int compareTo(ValueArray<StringValue> o) {
		StringValueArray other = (StringValueArray) o;

		// sorts first on number of data in the array, then comparison between
		// the first non-equal element in the arrays
		int cmp = Integer.compare(position, other.position);

		if (cmp != 0) {
			return cmp;
		}

		for (int i = 0; i < position; i++) {
			cmp = Byte.compare(data[i], other.data[i]);

			if (cmp != 0) {
				return cmp;
			}
		}

		return 0;
	}
1039611
public final <A extends Number & Comparable<?>> BooleanExpression goe(Expression<A> right) {
        return Expressions.booleanOperation(Ops.GOE, mixin, right);
    }
643285
public function compare(Type $left, Type $right)
    {
        return
            $right->accept(new TypeEquivalenceComparatorVisitor($this, $left));
    }
16841
@Override
	public int compareTo(Column o) {
		int diff = name.compareToIgnoreCase(o.name);
		if(diff!=0) return diff;
		return name.compareTo(o.name);
	}
61946
@SuppressWarnings({ "rawtypes", "unchecked" })
    public static int compareTo(final Comparable thisValue, final Comparable otherValue, final OrderDirection orderDirection, final OrderDirection nullOrderDirection) {
        if (null == thisValue && null == otherValue) {
            return 0;
        }
        if (null == thisValue) {
            return orderDirection == nullOrderDirection ? -1 : 1;
        }
        if (null == otherValue) {
            return orderDirection == nullOrderDirection ? 1 : -1;
        }
        return OrderDirection.ASC == orderDirection ? thisValue.compareTo(otherValue) : -thisValue.compareTo(otherValue);
    }
442937
public static int compare(Date left, double right) {
	return compare(left.getTime() / 1000, DateTimeUtil.getInstance().toDateTime(right).getTime() / 1000);
    }
687055
public static boolean areEqualTrimmed(final String left, final String right)
   {
      if ((left != null) && (right != null))
      {
         return left.trim().equals(right.trim());
      }
      return areEqual(left, right);
   }
786921
public static Boolean eq(Object left, Object right) {
        return EvalHelper.isEqual(left, right, null);
    }
1217205
public static boolean lessThan(SoyValue left, SoyValue right) {
    if (left instanceof SoyString && right instanceof SoyString) {
      return left.stringValue().compareTo(right.stringValue()) < 0;
    } else if (left instanceof IntegerData && right instanceof IntegerData) {
      return left.longValue() < right.longValue();
    } else {
      return left.numberValue() < right.numberValue();
    }
  }
1327912
public static Filter equalsFilter(String column, Object operand) {
      return new Filter(column, FilterOperator.EQUALS, operand);
    }