private static function cloneRemoveEqNotInTopLevelWorker($filter, $depth)
{
if ($filter instanceof PropertyNameFilter) {
$ret = new PropertyNameFilter($filter->getPropertyName());
return $ret;
} else {
if ($filter instanceof ConstantFilter) {
$ret = new ConstantFilter($filter->getEdmType(), $filter->getValue());
return $ret;
} else {
if ($filter instanceof UnaryFilter) {
$operand = self::cloneRemoveEqNotInTopLevelWorker($filter->getOperand(), $depth + 1);
$ret = new UnaryFilter($filter->getOperator(), $operand);
return $ret;
} else {
if ($filter instanceof BinaryFilter) {
if ($filter->getOperator() == 'eq' && $depth != 0) {
return Filter::applyConstant(false);
}
$left = self::cloneRemoveEqNotInTopLevelWorker($filter->getLeft(), $depth + 1);
$right = self::cloneRemoveEqNotInTopLevelWorker($filter->getRight(), $depth + 1);
$ret = new BinaryFilter($left, $filter->getOperator(), $right);
return $ret;
} else {
if ($filter instanceof QueryStringFilter) {
$ret = new QueryStringFilter($filter->getQueryString());
return $ret;
} else {
throw new \Exception();
}
}
}
}
}
}
/**
* @covers MicrosoftAzure\Storage\Table\Models\Query::setFilter
* @covers MicrosoftAzure\Storage\Table\Models\Query::getFilter
*/
public function testSetFilter()
{
// Setup
$query = new Query();
$expected = Filter::applyConstant('constValue', EdmType::STRING);
// Test
$query->setFilter($expected);
// Assert
$this->assertEquals($expected, $query->getFilter());
}
/**
* @covers MicrosoftAzure\Storage\Table\TableRestProxy::deleteEntity
* @covers MicrosoftAzure\Storage\Table\TableRestProxy::insertEntity
*/
public function testDeleteEntityTroublesomeRowKey()
{
// The service does not allow the following common characters in keys:
// 35 '#'
// 47 '/'
// 63 '?'
// 92 '\'
// In addition, the following values are not allowed, as they make the URL bad:
// 0-31, 127-159
// That still leaves several options for making troublesome keys
// spaces
// single quotes
// Unicode
// These need to be properly encoded when passed on the URL, else there will be trouble
$table = TableServiceFunctionalTestData::$testTableNames[0];
$e = new Entity();
$e->setRowKey('row\'Key\'');
$e->setPartitionKey('niceKey');
$this->restProxy->insertEntity($table, $e);
$this->restProxy->deleteEntity($table, $e->getPartitionKey(), $e->getRowKey());
$qopts = new QueryEntitiesOptions();
$qopts->setFilter(Filter::applyEq(Filter::applyPropertyName('RowKey'), Filter::applyConstant($e->getRowKey(), EdmType::STRING)));
$queryres = $this->restProxy->queryEntities($table, $qopts);
$this->assertEquals(0, count($queryres->getEntities()), 'entities returned');
$e = new Entity();
$e->setRowKey('row Key');
$e->setPartitionKey('niceKey');
$this->restProxy->insertEntity($table, $e);
$this->restProxy->deleteEntity($table, $e->getPartitionKey(), $e->getRowKey());
$qopts = new QueryEntitiesOptions();
$qopts->setFilter(Filter::applyEq(Filter::applyPropertyName('RowKey'), Filter::applyConstant($e->getRowKey(), EdmType::STRING)));
$queryres = $this->restProxy->queryEntities($table, $qopts);
$this->assertEquals(0, count($queryres->getEntities()), 'entities returned');
$e = new Entity();
$e->setRowKey('row ' . TableServiceFunctionalTestData::getUnicodeString());
$e->setPartitionKey('niceKey');
$this->restProxy->insertEntity($table, $e);
$this->restProxy->deleteEntity($table, $e->getPartitionKey(), $e->getRowKey());
$qopts = new QueryEntitiesOptions();
$qopts->setFilter(Filter::applyEq(Filter::applyPropertyName('RowKey'), Filter::applyConstant($e->getRowKey(), EdmType::STRING)));
$queryres = $this->restProxy->queryEntities($table, $qopts);
$this->assertEquals(0, count($queryres->getEntities()), 'entities returned');
$this->clearTable($table);
}
/**
* @covers MicrosoftAzure\Storage\Table\TableRestProxy::insertEntity
* @covers MicrosoftAzure\Storage\Table\TableRestProxy::queryEntities
*/
public function testQueryEntitiesWithFilterWorks()
{
// Arrange
$table = self::$testTable5;
$numberOfEntries = 5;
$entities = array();
for ($i = 0; $i < $numberOfEntries; $i++) {
$entity = new Entity();
$entity->setPartitionKey('001');
$entity->setRowKey('queryEntitiesWithFilterWorks-' . $i);
$entity->addProperty('test', EdmType::BOOLEAN, $i % 2 == 0);
$entity->addProperty('test2', EdmType::STRING, '\'value" ' . $i);
$entity->addProperty('test3', EdmType::INT32, $i);
$entity->addProperty('test4', EdmType::INT64, strval('12345678901' + $i));
$entity->addProperty('test5', EdmType::DATETIME, new \DateTime('2012-01-0' . $i));
$entity->addProperty('test6', EdmType::BINARY, chr($i));
$entity->addProperty('test7', EdmType::GUID, Utilities::getGuid());
$entities[$i] = $entity;
$this->restProxy->insertEntity($table, $entity);
}
// Act
$f = Filter::applyEq(Filter::applyPropertyName('RowKey'), Filter::applyConstant('queryEntitiesWithFilterWorks-3', EdmType::STRING));
$q = new Query();
$q->setFilter($f);
$qeo = new QueryEntitiesOptions();
$qeo->setQuery($q);
$result = $this->restProxy->queryEntities($table, $qeo);
// Assert
$this->assertNotNull($result, '$result');
$this->assertEquals(1, count($result->getEntities()), 'count($result->getEntities())');
$resEnts = $result->getEntities();
$this->assertEquals('queryEntitiesWithFilterWorks-3', $resEnts[0]->getRowKey(), '$resEnts[0]->getRowKey()');
// Act
$q = new Query();
$q->setFilter(Filter::applyQueryString('RowKey eq \'queryEntitiesWithFilterWorks-3\''));
$qeo = new QueryEntitiesOptions();
$qeo->setQuery($q);
$result = $this->restProxy->queryEntities($table, $qeo);
// Assert
$this->assertNotNull($result, '$result');
$this->assertEquals(1, count($result->getEntities()), 'count($result->getEntities())');
$resEnts = $result->getEntities();
$this->assertEquals('queryEntitiesWithFilterWorks-3', $resEnts[0]->getRowKey(), '$resEnts[0]->getRowKey()');
// Act
$q = new Query();
$q->setFilter(Filter::applyEq(Filter::applyPropertyName('test'), Filter::applyConstant(true, EdmType::BOOLEAN)));
$qeo = new QueryEntitiesOptions();
$qeo->setQuery($q);
$result = $this->restProxy->queryEntities($table, $qeo);
// Assert
$this->assertNotNull($result, '$result');
$this->assertEquals(3, count($result->getEntities()), 'count($result->getEntities())');
// Act
$q = new Query();
$q->setFilter(Filter::applyEq(Filter::applyPropertyName('test2'), Filter::applyConstant('\'value" 3', EdmType::STRING)));
$qeo = new QueryEntitiesOptions();
$qeo->setQuery($q);
$result = $this->restProxy->queryEntities($table, $qeo);
// Assert
$this->assertNotNull($result, '$result');
$this->assertEquals(1, count($result->getEntities()), 'count($result->getEntities())');
$resEnts = $result->getEntities();
$this->assertEquals('queryEntitiesWithFilterWorks-3', $resEnts[0]->getRowKey(), '$resEnts[0]->getRowKey()');
// Act
$q = new Query();
$q->setFilter(Filter::applyEq(Filter::applyPropertyName('test4'), Filter::applyConstant(12345678903, EdmType::INT64)));
$qeo = new QueryEntitiesOptions();
$qeo->setQuery($q);
$result = $this->restProxy->queryEntities($table, $qeo);
// Assert
$this->assertNotNull($result, '$result');
$this->assertEquals(1, count($result->getEntities()), 'count($result->getEntities())');
$resEnts = $result->getEntities();
$this->assertEquals('queryEntitiesWithFilterWorks-2', $resEnts[0]->getRowKey(), '$resEnts[0]->getRowKey()');
// Act
$q = new Query();
$q->setFilter(Filter::applyEq(Filter::applyPropertyName('test5'), Filter::applyConstant(new \DateTime('2012-01-03'), EdmType::DATETIME)));
$qeo = new QueryEntitiesOptions();
$qeo->setQuery($q);
$result = $this->restProxy->queryEntities($table, $qeo);
// Assert
$this->assertNotNull($result, '$result');
$this->assertEquals(1, count($result->getEntities()), 'count($result->getEntities())');
$resEnts = $result->getEntities();
$this->assertEquals('queryEntitiesWithFilterWorks-3', $resEnts[0]->getRowKey(), '$resEnts[0]->getRowKey()');
// Act
$q = new Query();
$ent3 = $entities[3];
$q->setFilter(Filter::applyEq(Filter::applyPropertyName('test6'), Filter::applyConstant(chr(3), EdmType::BINARY)));
$qeo = new QueryEntitiesOptions();
$qeo->setQuery($q);
$result = $this->restProxy->queryEntities($table, $qeo);
// Assert
$this->assertNotNull($result, '$result');
$this->assertEquals(1, count($result->getEntities()), 'count($result->getEntities())');
$resEnts = $result->getEntities();
$this->assertEquals('queryEntitiesWithFilterWorks-3', $resEnts[0]->getRowKey(), '$resEnts[0]->getRowKey()');
// Act
$q = new Query();
$ent3 = $entities[3];
$q->setFilter(Filter::applyEq(Filter::applyPropertyName('test7'), Filter::applyConstant($ent3->getPropertyValue('test7'), EdmType::GUID)));
$qeo = new QueryEntitiesOptions();
$qeo->setQuery($q);
$result = $this->restProxy->queryEntities($table, $qeo);
// Assert
$this->assertNotNull($result, '$result');
$this->assertEquals(1, count($result->getEntities()), 'count($result->getEntities())');
$resEnts = $result->getEntities();
$this->assertEquals('queryEntitiesWithFilterWorks-3', $resEnts[0]->getRowKey(), '$resEnts[0]->getRowKey()');
}
public function testCheckUnaryFilter()
{
$filter = new UnaryFilter(null, null);
$this->assertNotNull($filter, 'Default $filter');
$this->assertNull($filter->getOperand(), 'Default UnaryFilter->getOperand');
$this->assertNull($filter->getOperator(), 'Default UnaryFilter->getOperator');
$operand = new BinaryFilter(null, null, null);
$operator = 'foo';
$filter = new UnaryFilter($operator, $operand);
$this->assertEquals($operand, $filter->getOperand(), 'Set UnaryFilter->getOperand');
$this->assertEquals($operator, $filter->getOperator(), 'Set UnaryFilter->getOperator');
// Now check the factory.
$operand = new ConstantFilter(EdmType::STRING, null);
$filter = Filter::applyNot($operand);
$this->assertEquals($operand, $filter->getOperand(), 'Unary factory UnaryFilter->getOperand');
$this->assertEquals('not', $filter->getOperator(), 'Unary factory UnaryFilter->getOperator');
}
/**
* @covers MicrosoftAzure\Storage\Table\Models\Filters\Filter::applyLe
* @covers MicrosoftAzure\Storage\Table\Models\Filters\Filter::applyPropertyName
* @covers MicrosoftAzure\Storage\Table\Models\Filters\Filter::applyQueryString
*/
public function testApplyLe()
{
// Setup
$left = Filter::applyPropertyName('test');
$right = Filter::applyQueryString('raw string');
// Test
$actual = Filter::applyLe($left, $right);
// Assert
$this->assertEquals($left, $actual->getLeft());
$this->assertEquals($right, $actual->getRight());
}
private static function addBinaryFilter($name, $edmType, $values)
{
$counter = 0;
$ret = array();
foreach ($values as $o) {
$f = self::getBinaryFilterFromIndex($counter, Filter::applyPropertyName($name), Filter::applyConstant($o, $edmType));
$q = new Query();
$q->setFilter($f);
$qeo = new QueryEntitiesOptions();
$qeo->setQuery($q);
array_push($ret, $qeo);
$counter = ($counter + 1) % 6;
}
return $ret;
}
/**
* Quries entities for the given table name
*
* @param string $table The name of
* the table.
* @param Models\QueryEntitiesOptions|string|Models\Filter $options Coule be
* optional parameters, query string or filter to apply.
*
* @return Models\QueryEntitiesResult
*
* @see http://msdn.microsoft.com/en-us/library/windowsazure/dd179421.aspx
*/
public function queryEntities($table, $options = null)
{
Validate::isString($table, 'table');
Validate::notNullOrEmpty($table, 'table');
$method = Resources::HTTP_GET;
$headers = array();
$postParams = array();
$queryParams = array();
$statusCode = Resources::STATUS_OK;
$path = $table;
if (is_null($options)) {
$options = new QueryEntitiesOptions();
} else {
if (is_string($options)) {
$queryString = $options;
$options = new QueryEntitiesOptions();
$options->setFilter(Filter::applyQueryString($queryString));
} else {
if ($options instanceof Filter) {
$filter = $options;
$options = new QueryEntitiesOptions();
$options->setFilter($filter);
}
}
}
$queryParams = $this->_addOptionalQuery($queryParams, $options->getQuery());
$this->addOptionalQueryParam($queryParams, Resources::QP_TIMEOUT, $options->getTimeout());
$this->addOptionalQueryParam($queryParams, Resources::QP_NEXT_PK, $options->getNextPartitionKey());
$this->addOptionalQueryParam($queryParams, Resources::QP_NEXT_RK, $options->getNextRowKey());
$this->addOptionalHeader($headers, Resources::CONTENT_TYPE, Resources::XML_ATOM_CONTENT_TYPE);
if (!is_null($options->getQuery())) {
$dsHeader = Resources::DATA_SERVICE_VERSION;
$maxdsValue = Resources::MAX_DATA_SERVICE_VERSION_VALUE;
$fields = $options->getQuery()->getSelectFields();
$hasSelect = !empty($fields);
if ($hasSelect) {
$this->addOptionalHeader($headers, $dsHeader, $maxdsValue);
}
}
$response = $this->send($method, $headers, $queryParams, $postParams, $path, $statusCode);
$entities = $this->_atomSerializer->parseEntities($response->getBody());
return QueryEntitiesResult::create(HttpFormatter::formatHeaders($response->getHeaders()), $entities);
}
/**
* @covers MicrosoftAzure\Storage\Table\TableRestProxy::queryEntities
* @covers MicrosoftAzure\Storage\Table\TableRestProxy::_addOptionalQuery
* @covers MicrosoftAzure\Storage\Table\TableRestProxy::_encodeODataUriValues
* @covers MicrosoftAzure\Storage\Table\TableRestProxy::_encodeODataUriValue
* @covers MicrosoftAzure\Storage\Table\Internal\AtomReaderWriter::_parseBody
* @covers MicrosoftAzure\Storage\Table\Internal\AtomReaderWriter::parseEntities
* @covers MicrosoftAzure\Storage\Table\Internal\AtomReaderWriter::_parseOneEntity
* @covers MicrosoftAzure\Storage\Common\Internal\ServiceRestProxy::sendContext
*/
public function testQueryEntitiesFilterOption()
{
$this->skipIfEmulated();
// Setup
$name = 'queryentitieswithfilteroption';
$pk1 = '123';
$pk2 = '124';
$pk3 = '125';
$e1 = TestResources::getTestEntity($pk1, '1');
$e2 = TestResources::getTestEntity($pk2, '2');
$e3 = TestResources::getTestEntity($pk3, '3');
$this->createTable($name);
$this->restProxy->insertEntity($name, $e1);
$this->restProxy->insertEntity($name, $e2);
$this->restProxy->insertEntity($name, $e3);
$queryString = "PartitionKey eq '123'";
$filter = Filter::applyQueryString($queryString);
// Test
$result = $this->restProxy->queryEntities($name, $filter);
// Assert
$entities = $result->getEntities();
$this->assertCount(1, $entities);
$this->assertEquals($pk1, $entities[0]->getPartitionKey());
}
static function getInterestingQueryTablesOptions($isEmulated)
{
$ret = array();
$options = new QueryTablesOptions();
array_push($ret, $options);
$options = new QueryTablesOptions();
$options->setTop(2);
$options->setPrefix(self::$nonExistTablePrefix);
array_push($ret, $options);
$options = new QueryTablesOptions();
$options->setTop(-2);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyEq(Filter::applyConstant(self::$testTableNames[1]), Filter::applyPropertyName('TableName'));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyEq(Filter::applyConstant(self::$testTableNames[2]), Filter::applyPropertyName('TableName'));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyAnd(Filter::applyEq(Filter::applyConstant(self::$testTableNames[1]), Filter::applyPropertyName('TableName')), Filter::applyEq(Filter::applyConstant(self::$testTableNames[2]), Filter::applyPropertyName('TableName')));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyAnd(Filter::applyGe(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$testTableNames[1])), Filter::applyLe(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$testTableNames[2])));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyOr(Filter::applyGe(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$testTableNames[1])), Filter::applyGe(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$testTableNames[2])));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyAnd(Filter::applyEq(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$testTableNames[1])), Filter::applyGe(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$testTableNames[0])));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyOr(Filter::applyEq(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$testTableNames[1])), Filter::applyGe(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$testTableNames[2])));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyOr(Filter::applyEq(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$testTableNames[1])), Filter::applyEq(Filter::applyPropertyName('TableName'), Filter::applyConstant(self::$testTableNames[2])));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$filter = Filter::applyOr(Filter::applyEq(Filter::applyConstant(self::$testTableNames[1]), Filter::applyPropertyName('TableName')), Filter::applyEq(Filter::applyConstant(self::$testTableNames[2]), Filter::applyPropertyName('TableName')));
$options->setFilter($filter);
array_push($ret, $options);
$options = new QueryTablesOptions();
$options->setPrefix(self::$nonExistTablePrefix);
array_push($ret, $options);
if (!$isEmulated) {
$options = new QueryTablesOptions();
$options->setPrefix(self::$testUniqueId);
array_push($ret, $options);
}
$options = new QueryTablesOptions();
$nextTableName = self::$testTableNames[1];
$options->setNextTableName($nextTableName);
array_push($ret, $options);
$options = new QueryTablesOptions();
$nextTableName = self::$nonExistTablePrefix;
$options->setNextTableName($nextTableName);
array_push($ret, $options);
return $ret;
}
