fix: round 3 — DB adapter query coverage + null-type cross-type fallback

Database adapter: convertQueriesToDatabase() previously dropped
TYPE_NOT_EQUAL, TYPE_NOT_BETWEEN, TYPE_NOT_CONTAINS, TYPE_STARTS_WITH,
and TYPE_ENDS_WITH silently — the switch had no case for them so the
WHERE fragment was skipped, turning a "not X" or "starts with Y"
filter into a full-collection match. Adds all five.

ClickHouse adapter: find()/count()/getTimeSeries() with $type=null
queried both events and gauges. When the query referenced an
event-only attribute like 'path', the gauge iteration would throw
"Invalid attribute name: path" via parseQueries(). Adds a private
queriesMatchType() helper that pre-checks each filter attribute
against the type's schema; skip the table when not satisfied. The
caller now gets the events side without the gauge crash, which is
what null-type semantics should mean.

sum() takes type=TYPE_EVENT as a hard default, no null-type path.

Author: lohanidamodar

src/Usage/Adapter/ClickHouse.php

@@ -1500,9 +1500,14 @@ public function find(array $queries = [], ?string $type = null): array
         // Query both tables and merge. Each side already applied LIMIT, so
         // without a final cap callers asking for `limit(N)` could receive
         // up to 2N rows. Slice the merged result back down to the user's
-        // requested limit.
-        $events = $this->findFromTable($queries, Usage::TYPE_EVENT);
-        $gauges = $this->findFromTable($queries, Usage::TYPE_GAUGE);
+        // requested limit. Tables whose schema doesn't support every filter
+        // attribute (e.g. `path` on a gauge query) are skipped.
+        $events = $this->queriesMatchType($queries, Usage::TYPE_EVENT)
+            ? $this->findFromTable($queries, Usage::TYPE_EVENT)
+            : [];
+        $gauges = $this->queriesMatchType($queries, Usage::TYPE_GAUGE)
+            ? $this->findFromTable($queries, Usage::TYPE_GAUGE)
+            : [];
 
         $merged = array_merge($events, $gauges);
 
@@ -1513,6 +1518,38 @@ public function find(array $queries = [], ?string $type = null): array
         return $merged;
     }
 
+    /**
+     * Check whether every filter attribute in $queries exists on the schema
+     * for the given type. Used by the null-$type code paths in find/count/sum
+     * so a query with event-only attributes (path/method/status/etc.) silently
+     * skips the gauges table instead of throwing "Invalid attribute name".
+     *
+     * @param array<Query> $queries
+     */
+    private function queriesMatchType(array $queries, string $type): bool
+    {
+        foreach ($queries as $query) {
+            $attribute = $query->getAttribute();
+            if ($attribute === '' || $attribute === 'id') {
+                continue;
+            }
+            if ($attribute === 'tenant' && $this->sharedTables) {
+                continue;
+            }
+            $matched = false;
+            foreach ($this->getAttributes($type) as $schemaAttribute) {
+                if ($schemaAttribute['$id'] === $attribute) {
+                    $matched = true;
+                    break;
+                }
+            }
+            if (!$matched) {
+                return false;
+            }
+        }
+        return true;
+    }
+
     /**
      * Find metrics from a specific table.
      *
@@ -1752,8 +1789,15 @@ public function count(array $queries = [], ?string $type = null, ?int $max = nul
         // Count from both tables. Each per-table count is independently
         // capped at $max, so naively summing them could yield up to 2*$max.
         // Cap the combined total at $max in PHP to honour the contract.
-        $total = $this->countFromTable($queries, Usage::TYPE_EVENT, $max)
-               + $this->countFromTable($queries, Usage::TYPE_GAUGE, $max);
+        // Skip a table when its schema can't satisfy every filter attribute.
+        $events = $this->queriesMatchType($queries, Usage::TYPE_EVENT)
+            ? $this->countFromTable($queries, Usage::TYPE_EVENT, $max)
+            : 0;
+        $gauges = $this->queriesMatchType($queries, Usage::TYPE_GAUGE)
+            ? $this->countFromTable($queries, Usage::TYPE_GAUGE, $max)
+            : 0;
+
+        $total = $events + $gauges;
 
         if ($max !== null && $total > $max) {
             $total = $max;
@@ -2055,6 +2099,13 @@ public function getTimeSeries(array $metrics, string $interval, string $startDat
         }
 
         foreach ($typesToQuery as $queryType) {
+            // Skip a table when its schema can't satisfy every filter attribute
+            // (e.g. `path` on a gauge query); avoids "Invalid attribute name"
+            // when the caller leaves $type null and only one side is applicable.
+            if (!$this->queriesMatchType($queries, $queryType)) {
+                continue;
+            }
+
             $typeResult = $this->getTimeSeriesFromTable($metrics, $interval, $startDate, $endDate, $queries, $queryType);
 
             // Merge results

src/Usage/Adapter/Database.php

@@ -411,6 +411,36 @@ private function convertQueriesToDatabase(array $queries): array
                     /** @var array<array<int|string, mixed>|bool|float|int|string> $values */
                     $dbQueries[] = DatabaseQuery::contains($attribute, $values);
                     break;
+                case Query::TYPE_NOT_EQUAL:
+                    if (!empty($values)) {
+                        /** @var bool|float|int|string $value */
+                        $value = $values[0];
+                        $dbQueries[] = DatabaseQuery::notEqual($attribute, $value);
+                    }
+                    break;
+                case Query::TYPE_NOT_CONTAINS:
+                    /** @var array<array<int|string, mixed>|bool|float|int|string> $values */
+                    $dbQueries[] = DatabaseQuery::notContains($attribute, $values);
+                    break;
+                case Query::TYPE_NOT_BETWEEN:
+                    if (count($values) >= 2) {
+                        /** @var bool|float|int|string $start */
+                        $start = $values[0];
+                        /** @var bool|float|int|string $end */
+                        $end = $values[1];
+                        $dbQueries[] = DatabaseQuery::notBetween($attribute, $start, $end);
+                    }
+                    break;
+                case Query::TYPE_STARTS_WITH:
+                    if (!empty($values) && is_string($values[0])) {
+                        $dbQueries[] = DatabaseQuery::startsWith($attribute, $values[0]);
+                    }
+                    break;
+                case Query::TYPE_ENDS_WITH:
+                    if (!empty($values) && is_string($values[0])) {
+                        $dbQueries[] = DatabaseQuery::endsWith($attribute, $values[0]);
+                    }
+                    break;
                 case Query::TYPE_LESSER_EQUAL:
                     if (!empty($values)) {
                         /** @var bool|float|int|string $value */