public Status readSubset(String key, Set<String> fields, Map<String, ByteIterator> result) { String whereStr = String.format("RowKey eq '%s'", key); TableQuery<TableServiceEntity> projectionQuery = TableQuery.from( TableServiceEntity.class).where(whereStr).select(fields.toArray(new String[0])); EntityResolver<HashMap<String, ByteIterator>> resolver = new EntityResolver<HashMap<String, ByteIterator>>() { public HashMap<String, ByteIterator> resolve(String partitionkey, String rowKey, Date timeStamp, HashMap<String, EntityProperty> properties, String etag) { HashMap<String, ByteIterator> tmp = new HashMap<String, ByteIterator>(); for (Entry<String, EntityProperty> entry : properties.entrySet()) { String key = entry.getKey(); ByteIterator val = new ByteArrayByteIterator(entry.getValue().getValueAsByteArray()); tmp.put(key, val); } return tmp; } }; try { for (HashMap<String, ByteIterator> tmp : cloudTable.execute(projectionQuery, resolver)) { for (Entry<String, ByteIterator> entry : tmp.entrySet()){ String fieldName = entry.getKey(); ByteIterator fieldVal = entry.getValue(); result.put(fieldName, fieldVal); } } return Status.OK; } catch (Exception e) { return Status.ERROR; } }
@Override public UUID findFirst(JobAuthorization.State jobState) { try { String partitionFilter = generateFilterCondition( "PartitionKey", TableQuery.QueryComparisons.EQUAL, configuration.getPartitionKey()); String stateFilter = generateFilterCondition( "State", TableQuery.QueryComparisons.EQUAL, jobState.name()); // properties are converted to capitalized by the storage API String combinedFilter = TableQuery.combineFilters(partitionFilter, TableQuery.Operators.AND, stateFilter); TableQuery<DataWrapper> query = TableQuery.from(DataWrapper.class).where(combinedFilter).take(1); CloudTable table = tableClient.getTableReference(JOB_TABLE); Iterator<DataWrapper> iter = table.execute(query).iterator(); if (!iter.hasNext()) { return null; } return UUID.fromString(iter.next().getRowKey()); } catch (StorageException | URISyntaxException e) { throw new MicrosoftStorageException("Error finding first job", e); } }
private ImmutableList<ServiceEntity> allServiceEntities() { try (Timer.Context timerContext = listService.time()) { return tableClient.search(TableId.SERVICE, TableQuery .from(ServiceEntity.class)); } }
@Override public Optional<User> getUserForTimLocalId(String userId) throws AuthenticationUnavailableException { String query = "(PartitionKey eq 'users') and (id eq '" + userId + "')"; Iterator<DynamicTableEntity> users = table.execute(TableQuery.from(DynamicTableEntity.class) .where(query) .take(2)).iterator(); if (users.hasNext()) { Optional<User> result = Optional.of(propsToObject(users.next())); if (users.hasNext()) { LOG.error("Multiple items found for query " + query); } return result; } else { return Optional.empty(); } } }
private ImmutableList<ServiceEntity> allServiceEntities(ServiceId serviceId) { try (Timer.Context timerContext = listService.time()) { return tableClient.search(TableId.SERVICE, TableQuery .from(ServiceEntity.class) .where(partitionKeyEquals(serviceId))); } }
/** * Retrieve all rows in a table with the given partition key. * @param partitionKey Job model version of the processors to be retrieved. * @return Iterable list of processor entities. */ public Iterable<ProcessorEntity> getEntitiesWithPartition(String partitionKey) { String partitionFilter = TableQuery.generateFilterCondition(PARTITION_KEY, TableQuery.QueryComparisons.EQUAL, partitionKey); TableQuery<ProcessorEntity> partitionQuery = TableQuery.from(ProcessorEntity.class).where(partitionFilter); return table.execute(partitionQuery); }
@Override public void clearCheckpoints() { LOG.debug("Clearing all checkpoints in Azure table"); for (TaskName taskName : taskNames) { String partitionQueryKey = taskName.toString(); // Generate table query String partitionFilter = TableQuery.generateFilterCondition( PARTITION_KEY, TableQuery.QueryComparisons.EQUAL, partitionQueryKey); TableQuery<TaskCheckpointEntity> partitionQuery = TableQuery.from(TaskCheckpointEntity.class) .where(partitionFilter); // All entities in a given batch must have the same partition key deleteEntities(cloudTable.execute(partitionQuery).iterator()); } }
public Iterable<BlobDataTracker> getBlobDataTrackers(long msBack,String volid) { long tm = System.currentTimeMillis() - msBack; String partitionFilter = TableQuery.combineFilters(TableQuery.generateFilterCondition( PARTITION_KEY, QueryComparisons.EQUAL, volid), TableQuery.Operators.AND,TableQuery.generateFilterCondition( TIMESTAMP, QueryComparisons.LESS_THAN, new Date((long)(tm)))); TableQuery<BlobDataTracker> partitionQuery = TableQuery.from(BlobDataTracker.class) .where(partitionFilter); Iterable<BlobDataTracker> iter = cloudTable.execute(partitionQuery); return iter; }
private ImmutableList<DependencyEntity> getConfiguration(DependencyId dependencyId, long targetTimeStamp) { try (Timer.Context timerContext = dependencyConfigs.time()) { return tableClient.search(TableId.DEPENDENCY, TableQuery .from(DependencyEntity.class) .where(TableQuery.combineFilters( partitionEquals(dependencyId), TableQuery.Operators.AND, timestampEquals(targetTimeStamp)))); } }
@Test public void testQueryWithNullClassType() { try { TableQuery.from(null); } catch (IllegalArgumentException ex) { assertEquals(ex.getMessage(), String.format(SR.ARGUMENT_NULL_OR_EMPTY, "class type")); } }
@Override public Collection<DependencyModel> allDependenciesFor(DependencyId dependencyId, ServiceId serviceId) { try (Timer.Context timerContext = dependencyConfigs.time()) { return Entities.toDependencyModelList(tableClient.search( TableId.DEPENDENCY, TableQuery .from(DependencyEntity.class) .where(TableQuery.combineFilters( partitionEquals(dependencyId), TableQuery.Operators.AND, serviceIdEquals(serviceId))))); } }
@Test public void testQueryWithInvalidTakeCount() { try { TableQuery.from(TableServiceEntity.class).take(0); } catch (IllegalArgumentException ex) { assertEquals(ex.getMessage(), "Take count must be positive and greater than 0."); } try { TableQuery.from(TableServiceEntity.class).take(-1); } catch (IllegalArgumentException ex) { assertEquals(ex.getMessage(), "Take count must be positive and greater than 0."); } }
@Override public void deleteVreAuthorizations(String vreId) throws AuthorizationUnavailableException { String condition = TableQuery.generateFilterCondition( "PartitionKey", TableQuery.QueryComparisons.EQUAL, vreId ); TableBatchOperation deletes = new TableBatchOperation(); for (DynamicTableEntity entity : table.execute(TableQuery.from(DynamicTableEntity.class).where(condition))) { deletes.delete(entity); } try { table.execute(deletes); } catch (StorageException e) { LOG.error("deleteVreAuthorizations failed", e); throw new AuthorizationUnavailableException("Could not delete authorizations"); } }
private void testTableQueryProjectionWithSpecialCases(CloudTable table) { // Query on String and IntegerPrimitive TableQuery<ComplexEntity> query = TableQuery.from(ComplexEntity.class).select( new String[] { "String", "IntegerPrimitive"}); Iterable<ComplexEntity> iterable = table.execute(query); List<ComplexEntity> entities = new ArrayList<ComplexEntity>(); for (ComplexEntity entity : iterable) { entities.add(entity); } // Verify A has a set value and B and E have class defaults assertEquals(1, entities.size()); ComplexEntity entity = entities.get(0); assertNull(entity.getString()); assertEquals(-1, entity.getIntegerPrimitive()); }
private void testTableWithSelectOnMissingFields(TableRequestOptions options) throws StorageException { TableQuery<DynamicTableEntity> projectionQuery = TableQuery.from(DynamicTableEntity.class).where( "(PartitionKey eq 'javatables_batch_0') and (RowKey eq '000000')"); // A exists, F does not projectionQuery.select(new String[]{"A", "F"}); ResultSegment<DynamicTableEntity> seg = table.executeSegmented(projectionQuery, null, options, null); assertEquals(1, seg.getResults().size()); DynamicTableEntity ent = seg.getResults().get(0); assertEquals("foo_A", ent.getProperties().get("A").getValueAsString()); assertEquals(null, ent.getProperties().get("F").getValueAsString()); assertEquals(EdmType.STRING, ent.getProperties().get("F").getEdmType()); }
private void executeQueryAndAssertResults(String filter, int expectedResults, TableRequestOptions options, boolean usePropertyResolver) { // instantiate class to use property resolver ComplexEntity ent = new ComplexEntity(); if (usePropertyResolver) { options.setPropertyResolver(ent); } int count = 0; TableQuery<ComplexEntity> query = TableQuery.from(ComplexEntity.class).where(filter); for (@SuppressWarnings("unused") ComplexEntity e : table.execute(query, options, null)) { count++; } assertEquals(expectedResults, count); }
private void testTableQueryWithDynamicEntity(TableRequestOptions options) { // Create entity to check against Class1 randEnt = TableTestHelper.generateRandomEntity(null); final Iterable<DynamicTableEntity> result = table.execute(TableQuery.from(DynamicTableEntity.class), options, null); // Validate results for (DynamicTableEntity ent : result) { assertEquals(ent.getProperties().size(), 4); assertEquals(ent.getProperties().get("A").getValueAsString(), randEnt.getA()); assertEquals(ent.getProperties().get("B").getValueAsString(), randEnt.getB()); assertEquals(ent.getProperties().get("C").getValueAsString(), randEnt.getC()); assertTrue(Arrays.equals(ent.getProperties().get("D").getValueAsByteArray(), randEnt.getD())); } }
@Test public void testTableInvalidQuery() throws StorageException { TableRequestOptions options = new TableRequestOptions(); options.setTablePayloadFormat(TablePayloadFormat.Json); TableQuery<Class1> query = TableQuery.from(Class1.class).where( String.format("(PartitionKey ) and (RowKey ge '%s')", "000050")); try { table.executeSegmented(query, null, options, null); fail(); } catch (TableServiceException ex) { assertEquals(ex.getMessage(), "Bad Request"); assertTrue(ex.getExtendedErrorInformation().getErrorMessage() .startsWith("A binary operator with incompatible types was detected. Found operand types 'Edm.String' and 'Edm.Boolean' for operator kind 'And'.")); assertEquals(ex.getExtendedErrorInformation().getErrorCode(), "InvalidInput"); } }
private void testTableQueryWithSpecialChars(char charToTest, CloudTable table) throws StorageException, URISyntaxException { String partitionKey = "partition" + charToTest + "key"; String rowKey = "row" + charToTest + "key"; EmptyClass ref = new EmptyClass(); ref.setPartitionKey(partitionKey); ref.setRowKey(rowKey); table.execute(TableOperation.insert(ref)); String condition = TableQuery.generateFilterCondition(TableConstants.PARTITION_KEY, QueryComparisons.EQUAL, partitionKey); ResultSegment<EmptyClass> seg = table.executeSegmented(TableQuery.from(EmptyClass.class).where(condition), null); assertEquals(1, seg.getLength()); assertEquals(partitionKey, seg.getResults().get(0).getPartitionKey()); }
private void testTableQueryWithReflection(TableRequestOptions options, boolean usePropertyResolver) { // Create entity to check against Class1 randEnt = TableTestHelper.generateRandomEntity(null); if (usePropertyResolver) { options.setPropertyResolver(randEnt); } final Iterable<Class1> result = table.execute(TableQuery.from(Class1.class), options, null); // Validate results for (Class1 ent : result) { assertEquals(ent.getA(), randEnt.getA()); assertEquals(ent.getB(), randEnt.getB()); assertEquals(ent.getC(), randEnt.getC()); assertTrue(Arrays.equals(ent.getD(), randEnt.getD())); } }