@@ -451,7 +451,7 @@ _Flags always override settings in `.dbdiff`._
 | `--config=<file>` | Config file path. Defaults to `.dbdiff`. |
 | `--output=<path>` | Where to write. A **file path** for `native`, `liquibase-xml` and `liquibase-yaml`; a **directory** for `flyway` and `laravel`, which name their own files. Defaults to `migration.sql` in the current directory. |
 | `--memory-limit=<value>` | PHP memory limit for this run (e.g. `512M`, `1G`, `2G`, `-1` for unlimited). Overrides the 1G default and any `memory_limit` setting in your config file. |
-| `--tables=<list>` | Comma-separated table include list (supports globs: `*`, `?`). Only these tables are diffed. Example: `--tables=users,orders,wp_*` |
+| `--tables=<list>` | Comma-separated table include list (supports globs: `*`, `?`). Only these tables are diffed. Example: `--tables=users,orders,wp_*`. PostgreSQL with `--schemas`: a pattern with a schema (`app.*`, `public.orders`) matches in that schema only; one without matches the table in every schema. |
 | `--ignore-tables=<list>` | Comma-separated table exclude list (supports globs: `*`, `?`). Example: `--ignore-tables=cache_*,temp_*` |
 | `--schemas=<list>` | PostgreSQL: the schemas to compare (supports globs). Defaults to `public`. `--schemas='*'` compares every schema but the system's own; `--schemas=public,app` compares two. Objects outside `public` are named in full in the migration, and a schema only one side has is created or dropped. |
 | `--ignore-schemas=<list>` | PostgreSQL: schemas to skip (supports globs). On its own, compares every other schema. Example: `--ignore-schemas=auth,storage,extensions` |
 
@@ -1,5 +1,6 @@
 <?php namespace DBDiff\DB\Data;
 
+use DBDiff\DB\Support\SchemaScope;
 use DBDiff\Params\ParamsFactory;
 use DBDiff\Params\TableFilter;
 use DBDiff\Diff\SetDBCollation;
@@ -24,8 +25,9 @@ function getDiff() {
         $sourceTables = $this->manager->getTables('source');
         $targetTables = $this->manager->getTables('target');
 
-        $sourceTables = TableFilter::filterTables($sourceTables, $params, 'data');
-        $targetTables = TableFilter::filterTables($targetTables, $params, 'data');
+        $schema       = $this->manager->getDriver() === 'pgsql' ? SchemaScope::of($this->manager->getDB('source')) : null;
+        $sourceTables = TableFilter::filterTables($sourceTables, $params, 'data', $schema);
+        $targetTables = TableFilter::filterTables($targetTables, $params, 'data', $schema);
 
         $commonTables = array_intersect($sourceTables, $targetTables);
         foreach ($commonTables as $table) {
 
@@ -1,5 +1,6 @@
 <?php namespace DBDiff\DB\Schema;
 
+use DBDiff\DB\Support\SchemaScope;
 use Diff\Differ\ListDiffer;
 use Diff\DiffOp\DiffOpRemove;
 use Diff\DiffOp\DiffOpAdd;
@@ -91,8 +92,9 @@ function getDiff() {
         $targetTables = $this->manager->getTables('target');
 
         $allTables    = array_merge($sourceTables, $targetTables);
-        $sourceTables = TableFilter::filterTables($sourceTables, $params, 'schema');
-        $targetTables = TableFilter::filterTables($targetTables, $params, 'schema');
+        $schema       = $driver === 'pgsql' ? SchemaScope::of($this->manager->getDB('source')) : null;
+        $sourceTables = TableFilter::filterTables($sourceTables, $params, 'schema', $schema);
+        $targetTables = TableFilter::filterTables($targetTables, $params, 'schema', $schema);
 
         $addedTables = array_values(array_diff($sourceTables, $targetTables));
         $deletedTables = array_values(array_diff($targetTables, $sourceTables));
 
@@ -20,29 +20,34 @@ class TableFilter
      * @param string[] $tables       Raw table list from the adapter
      * @param object   $params       Params object (tables, tablesToIgnore, tablesDataToIgnore, tableScope)
      * @param string   $scope        'all' = both schema+data, 'schema' = schema only, 'data' = data only
+     * @param string|null $schema    PostgreSQL: the schema the tables are in, for patterns that name one
      * @return string[] Filtered table list (re-indexed)
      */
-    public static function filterTables(array $tables, object $params, string $scope = 'all'): array
+    public static function filterTables(array $tables, object $params, string $scope = 'all', ?string $schema = null): array
     {
+        $any = fn(string $table, array $patterns) => array_filter(
+            $patterns, fn(string $pattern) => self::matchesTable($table, $pattern, $schema)
+        ) !== [];
+
         // 1. Include list — keep only matching tables
         $includeList = $params->tables ?? null;
         if (!empty($includeList)) {
-            $tables = self::matchGlobs($tables, $includeList);
+            $tables = array_filter($tables, fn(string $t) => $any($t, (array) $includeList));
         }
 
         // 2. Exclude list — remove matching tables.
         //    When an include list is also active, the exclude list further
         //    narrows the included set (useful for "wp_* minus wp_wc_session*").
         $excludeList = $params->tablesToIgnore ?? null;
         if (!empty($excludeList)) {
-            $tables = self::rejectGlobs($tables, $excludeList);
+            $tables = array_filter($tables, fn(string $t) => !$any($t, (array) $excludeList));
         }
 
         // 3. Data-only exclusion — when in data scope, additionally exclude
         if ($scope === 'data') {
             $dataExclude = $params->tablesDataToIgnore ?? null;
             if (!empty($dataExclude)) {
-                $tables = self::rejectGlobs($tables, $dataExclude);
+                $tables = array_filter($tables, fn(string $t) => !$any($t, (array) $dataExclude));
             }
         }
 
@@ -51,8 +56,8 @@ public static function filterTables(array $tables, object $params, string $scope
         //    to 'schema' only.
         $tableScope = $params->tableScope ?? null;
         if (!empty($tableScope) && $scope !== 'all') {
-            $tables = array_filter($tables, function (string $name) use ($tableScope, $scope) {
-                $s = $tableScope[$name] ?? 'all';
+            $tables = array_filter($tables, function (string $name) use ($tableScope, $scope, $schema) {
+                $s = ($schema !== null ? $tableScope["$schema.$name"] ?? null : null) ?? $tableScope[$name] ?? 'all';
                 // 'all' → included in both schema and data
                 // 'schema' → included in schema only
                 // 'data' → included in data only
@@ -141,6 +146,20 @@ public static function filterRows(array $rows, array $rules): array
 
     // ── Glob helpers ──────────────────────────────────────────────────────
 
+    /**
+     * Whether a table pattern names this table. In PostgreSQL, where a diff
+     * may cover several schemas, a pattern with a dot is matched against the
+     * schema-qualified name (`app.*`, `public.orders`); one without matches
+     * the bare name in any schema, as it always has. SupaForge's own filter
+     * reads a pattern the same way.
+     */
+    public static function matchesTable(string $table, string $pattern, ?string $schema = null): bool
+    {
+        return $schema !== null && str_contains($pattern, '.')
+            ? self::globMatch($pattern, "$schema.$table")
+            : self::globMatch($pattern, $table);
+    }
+
     /**
      * Keep only items from $haystack that match any pattern in $patterns.
      *
 
@@ -501,4 +501,43 @@ public function testGlobMatchQuestionDoesNotMatchEmpty(): void
     {
         $this->assertFalse(TableFilter::globMatch('prefix?', 'prefix'));
     }
+
+    // ── Schema-qualified patterns (PostgreSQL, --schemas) ─────────────────
+
+    // A diff over several schemas reads one schema's tables at a time, by
+    // bare name: `app.*` matched nothing, and the user's filter did nothing.
+    public function testAPatternWithASchemaMatchesThatSchemaOnly(): void
+    {
+        $params = (object) ['tables' => ['app.*']];
+        $this->assertSame(['accounts', 'invoices'], TableFilter::filterTables(['accounts', 'invoices'], $params, 'schema', 'app'));
+        $this->assertSame([], TableFilter::filterTables(['accounts', 'invoices'], $params, 'schema', 'public'));
+    }
+
+    public function testABarePatternMatchesInEverySchemaAsBefore(): void
+    {
+        $params = (object) ['tables' => ['accounts']];
+        $this->assertSame(['accounts'], TableFilter::filterTables(['accounts', 'orders'], $params, 'schema', 'app'));
+        $this->assertSame(['accounts'], TableFilter::filterTables(['accounts', 'orders'], $params, 'schema', 'public'));
+    }
+
+    public function testExcludingOneSchemasTableLeavesTheOtherSchemas(): void
+    {
+        $params = (object) ['tablesToIgnore' => ['public.accounts']];
+        $this->assertSame(['orders'], TableFilter::filterTables(['accounts', 'orders'], $params, 'schema', 'public'));
+        $this->assertSame(['accounts', 'orders'], TableFilter::filterTables(['accounts', 'orders'], $params, 'schema', 'app'));
+    }
+
+    public function testAScopeKeyedByQualifiedNameWinsInItsSchema(): void
+    {
+        $params = (object) ['tableScope' => ['app.accounts' => 'schema', 'accounts' => 'data']];
+        $this->assertSame(['accounts'], TableFilter::filterTables(['accounts'], $params, 'schema', 'app'));
+        $this->assertSame([], TableFilter::filterTables(['accounts'], $params, 'schema', 'public'));
+    }
+
+    // Without a schema - MySQL, SQLite - a pattern is matched as written.
+    public function testWithoutASchemaAPatternIsMatchedAsWritten(): void
+    {
+        $this->assertFalse(TableFilter::matchesTable('accounts', 'app.*'));
+        $this->assertTrue(TableFilter::matchesTable('app.accounts', 'app.*'));
+    }
 }