@Override public void replaceAll(ImmutableBytesWritable srcPtr, byte[] rStrBytes, int rStrOffset, int rStrLen) { Preconditions.checkNotNull(srcPtr); Preconditions.checkNotNull(rStrBytes); String sourceStr = (String) PVarchar.INSTANCE.toObject(srcPtr); String replaceStr = (String) PVarchar.INSTANCE.toObject(rStrBytes, rStrOffset, rStrLen); if (srcPtr.getLength() == 0 && sourceStr == null) sourceStr = ""; if (rStrLen == 0 && replaceStr == null) replaceStr = ""; String replacedStr = pattern.matcher(sourceStr).replaceAll(replaceStr); srcPtr.set(PVarchar.INSTANCE.toBytes(replacedStr)); }
@Override public void matches(ImmutableBytesWritable srcPtr) { Preconditions.checkNotNull(srcPtr); String matcherSourceStr = (String) PVarchar.INSTANCE.toObject(srcPtr); if (srcPtr.getLength() == 0 && matcherSourceStr == null) matcherSourceStr = ""; boolean ret = pattern.matcher(matcherSourceStr).matches(); srcPtr.set(ret ? PDataType.TRUE_BYTES : PDataType.FALSE_BYTES); }
@Override public boolean split(ImmutableBytesWritable srcPtr) { String sourceStr = (String) PVarchar.INSTANCE.toObject(srcPtr); if (sourceStr == null) { // sourceStr evaluated to null srcPtr.set(ByteUtil.EMPTY_BYTE_ARRAY); } else { List<String> splitStrings = Lists.newArrayList(splitter.split(sourceStr)); PhoenixArray splitArray = new PhoenixArray(PVarchar.INSTANCE, splitStrings.toArray()); srcPtr.set(PVarcharArray.INSTANCE.toBytes(splitArray)); } return true; } }
@Override public void substr(ImmutableBytesWritable ptr, int offsetInStr) { Preconditions.checkNotNull(ptr); String sourceStr = (String) PVarchar.INSTANCE.toObject(ptr); if (sourceStr == null) { ptr.set(ByteUtil.EMPTY_BYTE_ARRAY); } else { if (offsetInStr < 0) offsetInStr += sourceStr.length(); if (offsetInStr < 0 || offsetInStr >= sourceStr.length()) { ptr.set(ByteUtil.EMPTY_BYTE_ARRAY); } else { Matcher matcher = pattern.matcher(sourceStr); boolean ret = matcher.find(offsetInStr); if (ret) { ptr.set(PVarchar.INSTANCE.toBytes(matcher.group())); } else { ptr.set(ByteUtil.EMPTY_BYTE_ARRAY); } } } } }
@Override public PColumn getColumnForColumnQualifier(byte[] cf, byte[] cq) throws ColumnNotFoundException, AmbiguousColumnException { Preconditions.checkNotNull(cq); if (!EncodedColumnsUtil.usesEncodedColumnNames(this) || cf == null) { String columnName = (String)PVarchar.INSTANCE.toObject(cq); return getColumnForColumnName(columnName); } else { String family = (String)PVarchar.INSTANCE.toObject(cf); PColumn col = kvColumnsByQualifiers.get(new KVColumnFamilyQualifier(family, cq)); if (col == null) { String schemaNameStr = schemaName==null?null:schemaName.getString(); String tableNameStr = tableName==null?null:tableName.getString(); throw new ColumnNotFoundException(schemaNameStr, tableNameStr, null, "No column found for column qualifier " + qualifierEncodingScheme.decode(cq)); } return col; } }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { Expression expression = getChildren().get(0); if (!expression.evaluate(tuple, ptr)) { return false; } String inputString = (String) PVarchar.INSTANCE.toObject(ptr, expression.getSortOrder()); if (LOG.isTraceEnabled()) { LOG.trace("CollationKey inputString: " + inputString); } if (inputString == null) { return true; } byte[] collationKeyByteArray = collator.getCollationKey(inputString).toByteArray(); if (LOG.isTraceEnabled()) { LOG.trace("CollationKey bytes: " + VarBinaryFormatter.INSTANCE.format(collationKeyByteArray)); } ptr.set(collationKeyByteArray); return true; }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { if (!getStrExpression().evaluate(tuple, ptr)) { return false; } String sourceStr = (String) PVarchar.INSTANCE.toObject(ptr, getStrExpression().getSortOrder()); if (sourceStr == null) { return true; } String resultStr = locale == null ? sourceStr.toUpperCase() : sourceStr.toUpperCase(locale); ptr.set(PVarchar.INSTANCE.toBytes(resultStr)); return true; }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { if (!getStrExpression().evaluate(tuple, ptr)) { return false; } if (ptr.getLength()==0) { return true; } String sourceStr = (String) PVarchar.INSTANCE.toObject(ptr, getStrExpression().getSortOrder()); if (sourceStr == null) { return true; } String resultStr = locale == null ? sourceStr.toLowerCase() : sourceStr.toLowerCase(locale); ptr.set(PVarchar.INSTANCE.toBytes(resultStr)); return true; }
private void init() { List<Expression> children = getChildren(); if (children.size() <= LIKE_TYPE_INDEX) { this.likeType = LikeType.CASE_SENSITIVE; } else { LiteralExpression likeTypeExpression = (LiteralExpression)children.get(LIKE_TYPE_INDEX); this.likeType = LikeType.valueOf((String)likeTypeExpression.getValue()); } ImmutableBytesWritable ptr = new ImmutableBytesWritable(); Expression e = getPatternExpression(); if (e.isStateless() && e.getDeterminism() == Determinism.ALWAYS && e.evaluate(null, ptr)) { String value = (String) PVarchar.INSTANCE.toObject(ptr, e.getDataType(), e.getSortOrder()); pattern = compilePattern(value); } }
private void init() { ImmutableBytesWritable ptr = new ImmutableBytesWritable(); Expression e = getPatternStrExpression(); if (e.isStateless() && e.getDeterminism() == Determinism.ALWAYS && e.evaluate(null, ptr)) { String pattern = (String) TYPE.toObject(ptr, TYPE, e.getSortOrder()); if (pattern != null) { initializedSplitter = compilePatternSpec(pattern); } } }
private void assertTable(String tableName1,List<Cell> keyValues1,String tableName2,List<Cell> keyValues2) { assertTrue("MUTATION_TEST1".equals(tableName1)); assertTrue(Bytes.equals(PUnsignedInt.INSTANCE.toBytes(111),CellUtil.cloneRow(keyValues1.get(0)))); assertTrue("app1".equals(PVarchar.INSTANCE.toObject(CellUtil.cloneValue(keyValues1.get(1))))); assertTrue("MUTATION_TEST2".equals(tableName2)); assertTrue(Bytes.equals(PUnsignedInt.INSTANCE.toBytes(222),CellUtil.cloneRow(keyValues2.get(0)))); assertTrue("app2".equals(PVarchar.INSTANCE.toObject(CellUtil.cloneValue(keyValues2.get(1))))); }
private static void assertTenantIds(Expression e, Table htable, Filter filter, String[] tenantIds) throws IOException { ImmutableBytesWritable ptr = new ImmutableBytesWritable(); Scan scan = new Scan(); scan.setFilter(filter); ResultScanner scanner = htable.getScanner(scan); Result result = null; ResultTuple tuple; Set<String> actualTenantIds = Sets.newHashSetWithExpectedSize(tenantIds.length); Set<String> expectedTenantIds = new HashSet<>(Arrays.asList(tenantIds)); while ((result = scanner.next()) != null) { tuple = new ResultTuple(result); e.evaluate(tuple, ptr); String tenantId = (String)PVarchar.INSTANCE.toObject(ptr); actualTenantIds.add(tenantId == null ? "" : tenantId); } assertTrue(actualTenantIds.containsAll(expectedTenantIds)); }
@Test public void testDegenerateBiggerThanMaxLengthVarchar() throws SQLException { byte[] tooBigValue = new byte[101]; Arrays.fill(tooBigValue, (byte)50); String aString = (String) PVarchar.INSTANCE.toObject(tooBigValue); String query = "select * from atable where a_string=?"; List<Object> binds = Arrays.<Object>asList(aString); PhoenixConnection pconn = DriverManager.getConnection(getUrl(), PropertiesUtil.deepCopy(TEST_PROPERTIES)).unwrap(PhoenixConnection.class); PhoenixPreparedStatement pstmt = newPreparedStatement(pconn, query); bindParams(pstmt, binds); QueryPlan plan = pstmt.optimizeQuery(); // Degenerate b/c a_string length is 100 assertDegenerate(plan.getContext()); }
private static void assertRow2(Iterator<Cell> iterator, byte[] expectedRowKey2) { Cell kv; kv = iterator.next(); assertArrayEquals(expectedRowKey2, CellUtil.cloneRow(kv)); assertEquals(QueryConstants.EMPTY_COLUMN_VALUE, PVarchar.INSTANCE.toObject(CellUtil.cloneValue(kv))); assertTrue(iterator.hasNext()); kv = iterator.next(); assertArrayEquals(expectedRowKey2, CellUtil.cloneRow(kv)); assertEquals(name2, PVarchar.INSTANCE.toObject(CellUtil.cloneValue(kv))); assertTrue(iterator.hasNext()); kv = iterator.next(); assertArrayEquals(expectedRowKey2, CellUtil.cloneRow(kv)); assertEquals(now, PDate.INSTANCE.toObject(CellUtil.cloneValue(kv))); }
private static void assertRow1(Iterator<Cell> iterator, byte[] expectedRowKey1) { Cell kv; assertTrue(iterator.hasNext()); kv = iterator.next(); assertArrayEquals(expectedRowKey1, CellUtil.cloneRow(kv)); assertEquals(QueryConstants.EMPTY_COLUMN_VALUE, PVarchar.INSTANCE.toObject(CellUtil.cloneValue(kv))); kv = iterator.next(); assertArrayEquals(expectedRowKey1, CellUtil.cloneRow(kv)); assertEquals(name1, PVarchar.INSTANCE.toObject(CellUtil.cloneValue(kv))); assertTrue(iterator.hasNext()); kv = iterator.next(); assertArrayEquals(expectedRowKey1, CellUtil.cloneRow(kv)); assertEquals(now, PDate.INSTANCE.toObject(CellUtil.cloneValue(kv))); }
@Test public void testPositionAtArrayElementWithDescArray(){ Object[] objects = new Object[]{"a", "b", null}; PhoenixArray arr = new PhoenixArray(PVarchar.INSTANCE, objects); byte[] bytes = PVarcharArray.INSTANCE.toBytes(arr, PVarchar.INSTANCE, SortOrder.DESC); ImmutableBytesWritable ptr = new ImmutableBytesWritable(bytes); PArrayDataTypeDecoder.positionAtArrayElement(ptr, 2, PVarchar.INSTANCE, null); String value = (String)PVarchar.INSTANCE.toObject(ptr, SortOrder.DESC); assertEquals(null, value); }
@Override public boolean evaluate(Tuple tuple, ImmutableBytesWritable ptr) { AbstractBaseSplitter splitter = initializedSplitter; if (splitter == null) { Expression e = getPatternStrExpression(); if (e.evaluate(tuple, ptr)) { String pattern = (String) TYPE.toObject(ptr, TYPE, e.getSortOrder()); if (pattern != null) { splitter = compilePatternSpec(pattern); } else { ptr.set(ByteUtil.EMPTY_BYTE_ARRAY); // set ptr to null return true; } } else { return false; } } Expression e = getSourceStrExpression(); if (!e.evaluate(tuple, ptr)) { return false; } TYPE.coerceBytes(ptr, TYPE, e.getSortOrder(), SortOrder.ASC); return splitter.split(ptr); }
private void init() { ImmutableBytesWritable tmpPtr = new ImmutableBytesWritable(); Expression e = getPatternStrExpression(); if (e.isStateless() && e.getDeterminism() == Determinism.ALWAYS && e.evaluate(null, tmpPtr)) { String patternStr = (String) TYPE.toObject(tmpPtr, e.getDataType(), e.getSortOrder()); if (patternStr != null) pattern = compilePatternSpec(patternStr); } e = getReplaceStrExpression(); if (e.isStateless() && e.getDeterminism() == Determinism.ALWAYS && e.evaluate(null, tmpPtr)) { TYPE.coerceBytes(tmpPtr, TYPE, e.getSortOrder(), SortOrder.ASC); rStrBytes = tmpPtr.get(); rStrOffset = tmpPtr.getOffset(); rStrLen = tmpPtr.getLength(); } else { rStrBytes = null; } }