Java TableQuery.generateFilterCondition方法代码示例

import com.microsoft.azure.storage.table.TableQuery; //导入方法依赖的package包/类
public String generateCombinedFilterConditions() {
    String filter = "";
    if (isValidFilterExpession()) {
        for (int idx = 0; idx < column.getValue().size(); idx++) {
            String c = column.getValue().get(idx);
            String cfn = function.getValue().get(idx);
            String cop = predicate.getValue().get(idx);
            String typ = fieldType.getValue().get(idx);

            String f = Comparison.getQueryComparisons(cfn);
            String v = operand.getValue().get(idx);
            String p = Predicate.getOperator(cop);

            EdmType t = SupportedFieldType.getEdmType(typ);

            String flt = TableQuery.generateFilterCondition(c, f, v, t);

            if (!filter.isEmpty()) {
                filter = TableQuery.combineFilters(filter, p, flt);
            } else {
                filter = flt;
            }
        }
    }
    return filter;
}
 

import com.microsoft.azure.storage.table.TableQuery; //导入方法依赖的package包/类
/**
 * Illustrates how to form and execute a query operation.
 * 
 * @throws StorageException
 */
public static void BasicQuery() throws StorageException {
    // Retrieve a single entity.
    // Retrieve the entity with partition key of "Smith" and row key of "Jeff".
    TableOperation retrieveSmithJeff = TableOperation.retrieve("Smith", "Jeff", CustomerEntity.class);

    // Submit the operation to the table service and get the specific entity.
    @SuppressWarnings("unused")
    CustomerEntity specificEntity = table.execute(retrieveSmithJeff).getResultAsType();

    // Retrieve all entities in a partition.
    // Create a filter condition where the partition key is "Smith".
    String partitionFilter = TableQuery.generateFilterCondition("PartitionKey", QueryComparisons.EQUAL, "Smith");

    // Specify a partition query, using "Smith" as the partition key filter.
    TableQuery<CustomerEntity> partitionQuery = TableQuery.from(CustomerEntity.class).where(partitionFilter);

    // Loop through the results, displaying information about the entity.
    for (CustomerEntity entity : table.execute(partitionQuery)) {
        System.out.println(entity.getPartitionKey() + " " + entity.getRowKey() + "\t" + entity.getEmail() + "\t"
                + entity.getPhoneNumber());
    }
}
 

import com.microsoft.azure.storage.table.TableQuery; //导入方法依赖的package包/类
@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");
  }
}
 

import com.microsoft.azure.storage.table.TableQuery; //导入方法依赖的package包/类
private static String partitionKeyEquals(ServiceId serviceId) {
    return TableQuery
            .generateFilterCondition(
                    PARTITION_KEY,
                    TableQuery.QueryComparisons.EQUAL,
                    serviceId.getId());
}
 

import com.microsoft.azure.storage.table.TableQuery; //导入方法依赖的package包/类
private static String timestampEquals(long timestamp) {
    return TableQuery.generateFilterCondition(
            ROW_KEY,
            TableQuery.QueryComparisons.EQUAL,
            String.valueOf(timestamp)
    );
}
 

import com.microsoft.azure.storage.table.TableQuery; //导入方法依赖的package包/类
/**
 * Create a filter condition that returns log lines between two dates. Designed to be used in addition to other criteria
 *
 * @param from
 * @param to
 *
 * @return
 */
public String createPartitionAndRowQuery(final DateTime from, final DateTime to)
{
	final String parMin = TableQuery.generateFilterCondition("PartitionKey",
	                                                         TableQuery.QueryComparisons.GREATER_THAN_OR_EQUAL,
	                                                         from.toLocalDate().toString());

	final String rowMin = TableQuery.generateFilterCondition("RowKey",
	                                                         TableQuery.QueryComparisons.GREATER_THAN_OR_EQUAL,
	                                                         LogLineTableEntity.toRowKey(from, null));

	if (to == null || from.toLocalDate().equals(to.toLocalDate()) || to.isAfterNow())
	{
		// There's no upper bound (or the upper bound doesn't make sense to include in the query)
		return andFilters(parMin, rowMin);
	}
	else
	{
		// From and To required

		final String parMax = TableQuery.generateFilterCondition("PartitionKey",
		                                                         TableQuery.QueryComparisons.LESS_THAN,
		                                                         to.toLocalDate().plusDays(1).toString());

		final String rowMax = TableQuery.generateFilterCondition("RowKey",
		                                                         TableQuery.QueryComparisons.LESS_THAN,
		                                                         LogLineTableEntity.toRowKey(to.plusSeconds(1), null));

		return andFilters(parMin, parMax, rowMin, rowMax);
	}
}
 

import com.microsoft.azure.storage.table.TableQuery; //导入方法依赖的package包/类
/**
 * 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);
}
 

import com.microsoft.azure.storage.table.TableQuery; //导入方法依赖的package包/类
private static String serviceIdEquals(ServiceId serviceId) {
    return TableQuery.generateFilterCondition(
            "ServiceName",
            TableQuery.QueryComparisons.EQUAL,
            serviceId.getId());
}
 

import com.microsoft.azure.storage.table.TableQuery; //导入方法依赖的package包/类
private static String partitionEquals(DependencyId dependencyId) {
    return TableQuery.generateFilterCondition(
            PARTITION_KEY,
            TableQuery.QueryComparisons.EQUAL,
            dependencyId.getId());
}