Object attribute query and index

src/Database/Adapter/Mongo.php

@@ -931,7 +931,13 @@ public function createIndex(string $collection, string $id, string $type, array
 
  foreach ($attributes as $i => $attribute) {
 
- $attributes[$i] = $this->filter($this->getInternalKeyForAttribute($attribute));
+ if (isset($indexAttributeTypes[$attribute]) && \str_contains($attribute, '.') && $indexAttributeTypes[$attribute] === Database::VAR_OBJECT) {
+ $dottedAttributes = \explode('.', $attribute);
+ $expandedAttributes = array_map(fn ($attr) => $this->filter($attr), $dottedAttributes);
+ $attributes[$i] = implode('.', $expandedAttributes);
+ } else {
+ $attributes[$i] = $this->filter($this->getInternalKeyForAttribute($attribute));
+ }
 
  $orderType = $this->getOrder($this->filter($orders[$i] ?? Database::ORDER_ASC));
  $indexes['key'][$attributes[$i]] = $orderType;
@@ -2499,7 +2505,7 @@ protected function buildFilter(Query $query): array
  };
 
  $filter = [];
- if ($query->isObjectAttribute() && in_array($query->getMethod(), [Query::TYPE_EQUAL, Query::TYPE_CONTAINS, Query::TYPE_NOT_CONTAINS, Query::TYPE_NOT_EQUAL])) {
+ if ($query->isObjectAttribute() && !\str_contains($attribute, '.') && in_array($query->getMethod(), [Query::TYPE_EQUAL, Query::TYPE_CONTAINS, Query::TYPE_NOT_CONTAINS, Query::TYPE_NOT_EQUAL])) {
  $this->handleObjectFilters($query, $filter);
  return $filter;
  }
@@ -2580,7 +2586,9 @@ private function handleObjectFilters(Query $query, array &$filter): void
  $flattendQuery = $this->flattenWithDotNotation(is_string($attribute) ? $attribute : '', $value);
  $flattenedObjectKey = array_key_first($flattendQuery);
  $queryValue = $flattendQuery[$flattenedObjectKey];
- $flattenedObjectKey = $query->getAttribute() . '.' . array_key_first($flattendQuery);
+ $queryAttribute = $query->getAttribute();
+ $flattenedQueryField = array_key_first($flattendQuery);
+ $flattenedObjectKey = $flattenedQueryField === '' ? $queryAttribute : $queryAttribute . '.' . array_key_first($flattendQuery);
  switch ($query->getMethod()) {
 
  case Query::TYPE_CONTAINS:

src/Database/Adapter/Postgres.php

@@ -886,15 +886,19 @@ public function createIndex(string $collection, string $id, string $type, array
 
  foreach ($attributes as $i => $attr) {
  $order = empty($orders[$i]) || Database::INDEX_FULLTEXT === $type ? '' : $orders[$i];
-
- $attr = match ($attr) {
- '$id' => '_uid',
- '$createdAt' => '_createdAt',
- '$updatedAt' => '_updatedAt',
- default => $this->filter($attr),
- };
-
- $attributes[$i] = "\"{$attr}\" {$order}";
+ $isNestedPath = isset($indexAttributeTypes[$attr]) && \str_contains($attr, '.') && $indexAttributeTypes[$attr] === Database::VAR_OBJECT;
+ if ($isNestedPath) {
+ $attributes[$i] = $this->buildJsonbPath($attr, true) . ($order ? " {$order}" : '');
+ } else {
+ $attr = match ($attr) {
+ '$id' => '_uid',
+ '$createdAt' => '_createdAt',
+ '$updatedAt' => '_updatedAt',
+ default => $this->filter($attr),
+ };
+
+ $attributes[$i] = "\"{$attr}\" {$order}";
+ }
  }
 
  $sqlType = match ($type) {
@@ -1748,9 +1752,14 @@ protected function handleObjectQueries(Query $query, array &$binds, string $attr
  protected function getSQLCondition(Query $query, array &$binds): string
  {
  $query->setAttribute($this->getInternalKeyForAttribute($query->getAttribute()));
+ $isNestedObjectAttribute = $query->isObjectAttribute() && \str_contains($query->getAttribute(), '.');
+ if ($isNestedObjectAttribute) {
+ $attribute = $this->buildJsonbPath($query->getAttribute());
+ } else {
+ $attribute = $this->filter($query->getAttribute());
+ $attribute = $this->quote($attribute);
+ }
 
- $attribute = $this->filter($query->getAttribute());
- $attribute = $this->quote($attribute);
  $alias = $this->quote(Query::DEFAULT_ALIAS);
  $placeholder = ID::unique();
 
@@ -1760,7 +1769,7 @@ protected function getSQLCondition(Query $query, array &$binds): string
  return $this->handleSpatialQueries($query, $binds, $attribute, $alias, $placeholder);
  }
 
- if ($query->isObjectAttribute()) {
+ if ($query->isObjectAttribute() && !$isNestedObjectAttribute) {
  return $this->handleObjectQueries($query, $binds, $attribute, $alias, $placeholder);
  }
 
@@ -2850,4 +2859,30 @@ public function getSupportForTTLIndexes(): bool
  {
  return false;
  }
+ protected function buildJsonbPath(string $path, bool $asText = false): string
+ {
+ $parts = \explode('.', $path);
+
+ foreach ($parts as $part) {
+ if (!preg_match('/^[a-zA-Z0-9_\-]+$/', $part)) {
+ throw new DatabaseException('Invalid JSON key ' . $part);
+ }
+ }
+ if (\count($parts) === 1) {
+ $column = $this->filter($parts[0]);
+ return $this->quote($column);
+ }
+
+ $baseColumn = $this->quote($this->filter(\array_shift($parts)));
+ $lastKey = \array_pop($parts);
+
+ $chain = $baseColumn;
+ foreach ($parts as $key) {
+ $chain .= "->'{$key}'";
+ }
+
+ $result = "{$chain}->>'{$lastKey}'";
+
+ return $asText ? "(({$result})::text)" : $result;
+ }
 }

src/Database/Database.php

@@ -1734,7 +1734,8 @@ public function createCollection(string $id, array $attributes = [], array $inde
  $this->adapter->getSupportForIndex(),
  $this->adapter->getSupportForUniqueIndex(),
  $this->adapter->getSupportForFulltextIndex(),
- $this->adapter->getSupportForTTLIndexes()
+ $this->adapter->getSupportForTTLIndexes(),
+ $this->adapter->getSupportForObject()
  );
  foreach ($indexes as $index) {
  if (!$validator->isValid($index)) {
@@ -2900,7 +2901,8 @@ public function updateAttribute(string $collection, string $id, ?string $type =
  $this->adapter->getSupportForIndex(),
  $this->adapter->getSupportForUniqueIndex(),
  $this->adapter->getSupportForFulltextIndex(),
- $this->adapter->getSupportForTTLIndexes()
+ $this->adapter->getSupportForTTLIndexes(),
+ $this->adapter->getSupportForObject()
  );
 
  foreach ($indexes as $index) {
@@ -4053,14 +4055,23 @@ public function createIndex(string $collection, string $id, string $type, array
  $collectionAttributes = $collection->getAttribute('attributes', []);
  $indexAttributesWithTypes = [];
  foreach ($attributes as $i => $attr) {
+ // Support nested paths on object attributes using dot notation:
+ // attribute.key.nestedKey -> base attribute "attribute"
+ $baseAttr = $attr;
+ if (\str_contains($attr, '.')) {
+ $baseAttr = \explode('.', $attr, 2)[0] ?? $attr;
+ }
+
  foreach ($collectionAttributes as $collectionAttribute) {
- if ($collectionAttribute->getAttribute('key') === $attr) {
- $indexAttributesWithTypes[$attr] = $collectionAttribute->getAttribute('type');
+ if ($collectionAttribute->getAttribute('key') === $baseAttr) {
+
+ $attributeType = $collectionAttribute->getAttribute('type');
+ $indexAttributesWithTypes[$attr] = $attributeType;
 
  /**
  * mysql does not save length in collection when length = attributes size
  */
- if ($collectionAttribute->getAttribute('type') === Database::VAR_STRING) {
+ if ($attributeType === self::VAR_STRING) {
  if (!empty($lengths[$i]) && $lengths[$i] === $collectionAttribute->getAttribute('size') && $this->adapter->getMaxIndexLength() > 0) {
  $lengths[$i] = null;
  }
@@ -4108,7 +4119,8 @@ public function createIndex(string $collection, string $id, string $type, array
  $this->adapter->getSupportForIndex(),
  $this->adapter->getSupportForUniqueIndex(),
  $this->adapter->getSupportForFulltextIndex(),
- $this->adapter->getSupportForTTLIndexes()
+ $this->adapter->getSupportForTTLIndexes(),
+ $this->adapter->getSupportForObject()
  );
  if (!$validator->isValid($index)) {
  throw new IndexException($validator->getDescription());
@@ -8642,11 +8654,20 @@ public function convertQuery(Document $collection, Query $query): Query
  $attributes[] = new Document($attribute);
  }
 
+ $queryAttribute = $query->getAttribute();
+ $isNestedQueryAttribute = $this->getAdapter()->getSupportForAttributes() && $this->getAdapter()->getSupportForObject() && \str_contains($queryAttribute, '.');
+
  $attribute = new Document();
 
  foreach ($attributes as $attr) {
  if ($attr->getId() === $query->getAttribute()) {
  $attribute = $attr;
+ } elseif ($isNestedQueryAttribute) {
+ // nested object query
+ $baseAttribute = \explode('.', $queryAttribute, 2)[0];
+ if ($baseAttribute === $attr->getId() && $attr->getAttribute('type') === Database::VAR_OBJECT) {
+ $query->setAttributeType(Database::VAR_OBJECT);
+ }
  }
  }
 

src/Database/Validator/Index.php

@@ -34,6 +34,7 @@ class Index extends Validator
  * @param bool $supportForKeyIndexes
  * @param bool $supportForUniqueIndexes
  * @param bool $supportForFulltextIndexes
+ * @param bool $supportForObjects
  * @throws DatabaseException
  */
  public function __construct(
@@ -55,6 +56,7 @@ public function __construct(
  protected bool $supportForUniqueIndexes = true,
  protected bool $supportForFulltextIndexes = true,
  protected bool $supportForTTLIndexes = false,
+ protected bool $supportForObjects = false
  ) {
  foreach ($attributes as $attribute) {
  $key = \strtolower($attribute->getAttribute('key', $attribute->getAttribute('$id')));
@@ -170,6 +172,20 @@ public function isValid($value): bool
  public function checkValidIndex(Document $index): bool
  {
  $type = $index->getAttribute('type');
+ if ($this->supportForObjects) {
+ // getting dotted attributes not present in schema
+ $dottedAttributes = array_filter($index->getAttribute('attributes'), fn ($attr) => !isset($this->attributes[\strtolower($attr)]) && $this->isDottedAttribute($attr));
+ if (\count($dottedAttributes)) {
+ foreach ($dottedAttributes as $attribute) {
+ $baseAttribute = $this->getBaseAttributeFromDottedAttribute($attribute);
+ if (isset($this->attributes[\strtolower($baseAttribute)]) && $this->attributes[\strtolower($baseAttribute)]->getAttribute('type') != Database::VAR_OBJECT) {
+ $this->message = 'Index attribute "' . $attribute . '" is only supported on object attributes';
+ return false;
+ };
+ }
+ }
+ }
+
  switch ($type) {
  case Database::INDEX_KEY:
  if (!$this->supportForKeyIndexes) {
@@ -246,8 +262,19 @@ public function checkValidIndex(Document $index): bool
  */
  public function checkValidAttributes(Document $index): bool
  {
+ if (!$this->supportForAttributes) {
+ return true;
+ }
  foreach ($index->getAttribute('attributes', []) as $attribute) {
- if ($this->supportForAttributes && !isset($this->attributes[\strtolower($attribute)])) {
+ // attribute is part of the attributes
+ // or object indexes supported and its a dotted attribute with base present in the attributes
+ if (!isset($this->attributes[\strtolower($attribute)])) {
+ if ($this->supportForObjects) {
+ $baseAttribute = $this->getBaseAttributeFromDottedAttribute($attribute);
+ if (isset($this->attributes[\strtolower($baseAttribute)])) {
+ continue;
+ }
+ }
  $this->message = 'Invalid index attribute "' . $attribute . '" not found';
  return false;
  }
@@ -399,6 +426,9 @@ public function checkIndexLengths(Document $index): bool
  return false;
  }
  foreach ($attributes as $attributePosition => $attributeName) {
+ if ($this->supportForObjects && !isset($this->attributes[\strtolower($attributeName)])) {
+ $attributeName = $this->getBaseAttributeFromDottedAttribute($attributeName);
+ }
  $attribute = $this->attributes[\strtolower($attributeName)];
 
  switch ($attribute->getAttribute('type')) {
@@ -756,6 +786,14 @@ public function checkObjectIndexes(Document $index): bool
  }
 
  $attributeName = $attributes[0] ?? '';
+
+ // Object indexes are only allowed on the top-level object attribute,
+ // not on nested paths like "data.key.nestedKey".
+ if (\strpos($attributeName, '.') !== false) {
+ $this->message = 'Object index can only be created on a top-level object attribute';
+ return false;
+ }
+
  $attribute = $this->attributes[\strtolower($attributeName)] ?? new Document();
  $attributeType = $attribute->getAttribute('type', '');
 
@@ -812,4 +850,14 @@ public function checkTTLIndexes(Document $index): bool
 
  return true;
  }
+
+ private function isDottedAttribute(string $attribute): bool
+ {
+ return \str_contains($attribute, '.');
+ }
+
+ private function getBaseAttributeFromDottedAttribute(string $attribute): string
+ {
+ return $this->isDottedAttribute($attribute) ? \explode('.', $attribute, 2)[0] ?? '' : $attribute;
+ }
 }

src/Database/Validator/Query/Filter.php

@@ -85,6 +85,7 @@ protected function isValidAttributeAndValues(string $attribute, array $values, s
 
  $originalAttribute = $attribute;
  // isset check if for special symbols "." in the attribute name
+ // same for nested path on object
  if (\str_contains($attribute, '.') && !isset($this->schema[$attribute])) {
  // For relationships, just validate the top level.
  // Utopia will validate each nested level during the recursive calls.
@@ -126,6 +127,8 @@ protected function isValidAttributeAndValues(string $attribute, array $values, s
 
  $attributeType = $attributeSchema['type'];
 
+ $isDottedOnObject = \str_contains($originalAttribute, '.') && $attributeType === Database::VAR_OBJECT;
+
  // If the query method is spatial-only, the attribute must be a spatial type
  $query = new Query($method);
  if ($query->isSpatialQuery() && !in_array($attributeType, Database::SPATIAL_TYPES, true)) {
@@ -178,13 +181,20 @@ protected function isValidAttributeAndValues(string $attribute, array $values, s
  break;
 
  case Database::VAR_OBJECT:
- if (\in_array($method, [Query::TYPE_EQUAL, Query::TYPE_NOT_EQUAL, Query::TYPE_CONTAINS, Query::TYPE_NOT_CONTAINS], true)
+ // For dotted attributes on objects, validate as string (path queries)
+ if ($isDottedOnObject) {
+ $validator = new Text(0, 0);
+ continue 2;
+ }
+
+ // object containment queries on the base object attribute
+ elseif (\in_array($method, [Query::TYPE_EQUAL, Query::TYPE_NOT_EQUAL, Query::TYPE_CONTAINS, Query::TYPE_NOT_CONTAINS], true)
  && !$this->isValidObjectQueryValues($value)) {
  $this->message = 'Invalid object query structure for attribute "' . $attribute . '"';
  return false;
  }
- continue 2;
 
+ continue 2;
  case Database::VAR_POINT:
  case Database::VAR_LINESTRING:
  case Database::VAR_POLYGON: