/** * Returns the SortOrder instance for the specified internal value. */ public static SortOrder fromSystemValue(int value) { for (SortOrder mod : SortOrder.values()) { if (mod.getSystemValue() == value) { return mod; } } return getDefault(); }
@Test public void systemValue() { assertSame(SortOrder.ASC, SortOrder.fromSystemValue(SortOrder.ASC.getSystemValue())); assertSame(SortOrder.DESC, SortOrder.fromSystemValue(SortOrder.DESC.getSystemValue())); assertSame(SortOrder.ASC, SortOrder.fromSystemValue(0)); }
public static int serializeNulls(byte[] bytes, int position, int nulls) { int nMultiplesOver255 = nulls / 255; while (nMultiplesOver255-- > 0) { bytes[position++] = 1; } int nRemainingNulls = nulls % 255; if (nRemainingNulls > 0) { byte nNullByte = SortOrder.invert((byte)(nRemainingNulls - 1)); bytes[position++] = nNullByte; } return position; }
@Override public String toString() { int maxToStringLen = 200; Expression firstChild = children.get(0); PDataType type = firstChild.getDataType(); StringBuilder buf = new StringBuilder(firstChild + " IN ("); for (ImmutableBytesPtr value : values) { ImmutableBytesWritable currValue = value; if (firstChild.getSortOrder() != null && !firstChild.getSortOrder().equals(SortOrder.getDefault())) { // if we have to invert the bytes create a new ImmutableBytesWritable so that the // original value is not changed currValue = new ImmutableBytesWritable(value); type.coerceBytes(currValue, type, firstChild.getSortOrder(), SortOrder.getDefault()); } buf.append(type.toStringLiteral(currValue, null)); buf.append(','); if (buf.length() >= maxToStringLen) { buf.append("... "); break; } } buf.setCharAt(buf.length()-1,')'); return buf.toString(); }
if ( state.backtracking==0 ) {ret = Pair.newPair(x, order == null ? SortOrder.getDefault() : SortOrder.fromDDLValue(order.getText()));}
/** * Identify the tables that need to be upgraded due to PHOENIX-2067 and PHOENIX-2120 */ public static List<String> getPhysicalTablesWithDescRowKey(PhoenixConnection conn) throws SQLException { String query = "SELECT TENANT_ID,TABLE_SCHEM,TABLE_NAME\n" + "FROM SYSTEM.CATALOG cat1\n" + "WHERE COLUMN_NAME IS NOT NULL\n" + "AND COLUMN_FAMILY IS NULL\n" + "AND ( ( SORT_ORDER = " + SortOrder.DESC.getSystemValue() + "\n" + " AND DATA_TYPE IN " + getAffectedDataTypes() + ")\n" + " OR ( SORT_ORDER = " + SortOrder.ASC.getSystemValue() + "\n" + " AND DATA_TYPE = " + PBinary.INSTANCE.getSqlType() + "\n" + " AND COLUMN_SIZE > 1 ) )\n" + "GROUP BY TENANT_ID,TABLE_SCHEM,TABLE_NAME"; return getPhysicalTablesWithDescRowKey(query, conn); }
@Override public SortOrder getSortOrder() { return SortOrder.getDefault(); } };
@Override public void readFields(DataInput input) throws IOException { int encodedByteLengthAndBool = WritableUtils.readVInt(input); int byteLength = Math.abs(encodedByteLengthAndBool)-1; this.byteValue = new byte[byteLength]; input.readFully(byteValue, 0, byteLength); int sortOrderAndDeterminism = WritableUtils.readVInt(input); if (sortOrderAndDeterminism<=2) { //client is on an older version this.determinism = encodedByteLengthAndBool > 0 ? Determinism.ALWAYS : Determinism.PER_ROW; this.sortOrder = SortOrder.fromSystemValue(sortOrderAndDeterminism);; } else { int determinismOrdinal = (sortOrderAndDeterminism>>2)-1; this.determinism = Determinism.values()[determinismOrdinal]; int sortOrderValue = sortOrderAndDeterminism & ((1 << 2) - 1); //get the least 2 significant bits this.sortOrder = SortOrder.fromSystemValue(sortOrderValue); } int typeOrdinal = WritableUtils.readVInt(input); if (typeOrdinal < 0) { this.type = null; } else { this.type = PDataType.values()[typeOrdinal]; } if (this.byteValue.length == 0) { this.value = null; } else { this.value = this.type.toObject(byteValue, 0, byteValue.length, this.type, sortOrder); } }
if (lhsLength > rhsLength) { int minOffset = lhsOffset + rhsLength; for (int i = lhsOffset + lhsLength - 1; i >= minOffset && lhsSortOrder.normalize(lhs[i]) == 0; i--,lhsLength--) { for (int i = rhsOffset + rhsLength - 1; i >= minOffset && rhsSortOrder.normalize(rhs[i]) == 0; i--,rhsLength--) { lhs = SortOrder.invert(lhs, lhsOffset, new byte[lhsLength], 0, lhsLength); lhsOffset = 0; rhs = SortOrder.invert(rhs, rhsOffset, new byte[rhsLength], 0, rhsLength);
Integer maxLength = columnSizeKv == null ? null : PInteger.INSTANCE.getCodec().decodeInt( columnSizeKv.getValueArray(), columnSizeKv.getValueOffset(), SortOrder.getDefault()); Cell decimalDigitKv = colKeyValues[DECIMAL_DIGITS_INDEX]; Integer scale = decimalDigitKv == null ? null : PInteger.INSTANCE.getCodec().decodeInt( decimalDigitKv.getValueArray(), decimalDigitKv.getValueOffset(), SortOrder.getDefault()); Cell ordinalPositionKv = colKeyValues[ORDINAL_POSITION_INDEX]; int position = PInteger.INSTANCE.getCodec().decodeInt(ordinalPositionKv.getValueArray(), ordinalPositionKv.getValueOffset(), SortOrder.getDefault()) + (isSalted ? 1 : 0);; boolean isNullable = PInteger.INSTANCE.getCodec().decodeInt(nullableKv.getValueArray(), nullableKv.getValueOffset(), SortOrder.getDefault()) != ResultSetMetaData.columnNoNulls; Cell dataTypeKv = colKeyValues[DATA_TYPE_INDEX]; PDataType dataType = PDataType.fromTypeId(PInteger.INSTANCE.getCodec().decodeInt( dataTypeKv.getValueArray(), dataTypeKv.getValueOffset(), SortOrder.getDefault())); if (maxLength == null && dataType == PBinary.INSTANCE) dataType = PVarbinary.INSTANCE; // For sortOrderKv == null ? SortOrder.getDefault() : SortOrder.fromSystemValue(PInteger.INSTANCE .getCodec().decodeInt(sortOrderKv.getValueArray(), sortOrderKv.getValueOffset(), SortOrder.getDefault())); PInteger.INSTANCE.getCodec().decodeInt(arraySizeKv.getValueArray(), arraySizeKv.getValueOffset(), SortOrder.getDefault());
if (sortOrder != existingViewColumn.getSortOrder().getSystemValue()) { return new MetaDataMutationResult(MutationCode.UNALLOWED_TABLE_MUTATION, EnvironmentEdgeManager.currentTimeMillis(), basePhysicalTable); int keySeq = PSmallint.INSTANCE.getCodec().decodeInt(cell.getValueArray(), cell.getValueOffset(), SortOrder.getDefault());
@Test public void ascSortOrderDoesNotTransformOp() { for (CompareOp op : CompareOp.values()) { assertSame(op, SortOrder.ASC.transform(op)); } }
@Test public void ddlValue() { assertSame(SortOrder.ASC, SortOrder.fromDDLValue("ASC")); assertSame(SortOrder.ASC, SortOrder.fromDDLValue("asc")); assertSame(SortOrder.ASC, SortOrder.fromDDLValue("aSc")); assertSame(SortOrder.DESC, SortOrder.fromDDLValue("DESC")); assertSame(SortOrder.DESC, SortOrder.fromDDLValue("desc")); assertSame(SortOrder.DESC, SortOrder.fromDDLValue("DesC")); try { SortOrder.fromDDLValue("foo"); } catch (IllegalArgumentException expected) { } }
@Test public void testNonPKCompare() throws Exception { List<Integer> expectedResults = Lists.newArrayList(2,3,4); Integer[] saltBuckets = new Integer[] {null,3}; PDataType[] dataTypes = new PDataType[] {PDecimal.INSTANCE, PDouble.INSTANCE, PFloat.INSTANCE}; for (Integer saltBucket : saltBuckets) { for (PDataType dataType : dataTypes) { for (SortOrder sortOrder : SortOrder.values()) { testCompareCompositeKey(saltBucket, dataType, sortOrder, "", expectedResults, ""); } } } }
@Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + byteSize; result = prime * result + (type == null ? 0 : type.hashCode()); result = prime * result + sortOrder.hashCode(); result = prime * result + (isNullable ? 1231 : 1237); return result; }
protected static int[] getDecimalPrecisionAndScale(byte[] bytes, int offset, int length, SortOrder sortOrder) { if (length == 1 && sortOrder.normalize(bytes[offset]) == ZERO_BYTE) { return new int[] { 0, 0 }; } int signum = ((sortOrder.normalize(bytes[offset]) & 0x80) == 0) ? -1 : 1; int scale; int index; int digitOffset; if (signum == 1) { scale = (byte)(((sortOrder.normalize(bytes[offset]) & 0x7F) - 65) * -2); index = offset + length; digitOffset = POS_DIGIT_OFFSET; } else { scale = (byte)((~sortOrder.normalize(bytes[offset]) - 65 - 128) * -2); index = offset + length - (sortOrder.normalize(bytes[offset + length - 1]) == NEG_TERMINAL_BYTE ? 1 : 0); digitOffset = -NEG_DIGIT_OFFSET; int d = signum * sortOrder.normalize(bytes[--index]) - digitOffset; if (d % 10 == 0) { // trailing zero precision -= 1; d = signum * sortOrder.normalize(bytes[offset + 1]) - digitOffset; if (d < 10) { // Leading single digit
if ( state.backtracking==0 ) { ret = factory.columnDefInPkConstraint(factory.columnName(f), order == null ? SortOrder.getDefault() : SortOrder.fromDDLValue(order.getText()), rr != null); }
/** * Identify the tables that are DESC VARBINARY as this is no longer supported */ public static List<String> getPhysicalTablesWithDescVarbinaryRowKey(PhoenixConnection conn) throws SQLException { String query = "SELECT TENANT_ID,TABLE_SCHEM,TABLE_NAME\n" + "FROM SYSTEM.CATALOG cat1\n" + "WHERE COLUMN_NAME IS NOT NULL\n" + "AND COLUMN_FAMILY IS NULL\n" + "AND SORT_ORDER = " + SortOrder.DESC.getSystemValue() + "\n" + "AND DATA_TYPE = " + PVarbinary.INSTANCE.getSqlType() + "\n" + "GROUP BY TENANT_ID,TABLE_SCHEM,TABLE_NAME"; return getPhysicalTablesWithDescRowKey(query, conn); }
@Override public SortOrder getSortOrder() { return SortOrder.getDefault(); } };
private static void compareExperssions(int i, Expression expression, List<TargetDataExpression> targetTypes) throws SQLException { PDataType type = expression.getDataType(); if (type != null && type.isCoercibleTo(targetTypes.get(i).getType())) { ; } else if (targetTypes.get(i).getType() == null || targetTypes.get(i).getType().isCoercibleTo(type)) { targetTypes.get(i).setType(type); } else { throw new SQLExceptionInfo.Builder(SQLExceptionCode .SELECT_COLUMN_TYPE_IN_UNIONALL_DIFFS).setMessage("Column # " + i + " is " + targetTypes.get(i).getType().getSqlTypeName() + " in 1st query where as it is " + type.getSqlTypeName() + " in 2nd query") .build().buildException(); } Integer len = expression.getMaxLength(); if (len != null && (targetTypes.get(i).getMaxLength() == null || len > targetTypes.get(i).getMaxLength())) { targetTypes.get(i).setMaxLength(len); } Integer scale = expression.getScale(); if (scale != null && (targetTypes.get(i).getScale() == null || scale > targetTypes.get(i).getScale())){ targetTypes.get(i).setScale(scale); } SortOrder sortOrder = expression.getSortOrder(); if (sortOrder != null && (!sortOrder.equals(targetTypes.get(i).getSortOrder()))) targetTypes.get(i).setSortOrder(SortOrder.getDefault()); }