dropAllTables

CHANGELOG.md

@@ -1,7 +1,9 @@
 # v6.2.0 (Not Released Yet)
 
 Added
-- `json` `mediumText` `longText` `char` support for `Schema\Builder` (#155) (#158)
+- `json` `mediumText` `longText` support for `Schema\Builder` (#155)
+- `Schema\Grammar::compileDropForeign` to allow dropping foreign key constraints (#163)
+- `Schema\Builder::dropAllTables` works properly, dropping foreign keys, indexes, then tables in order of interleaving (#161)
 
 Changed
 - `Query\Builder::lock()` no longer throw an error and will be ignored instead (#156)

phpunit.xml

@@ -27,6 +27,7 @@
          stopOnFailure="true">
   <testsuite name="all">
     <directory suffix="Test.php">./tests</directory>
+    <directory suffix="TestLast.php">./tests</directory>
   </testsuite>
   <php>
     <env name="SPANNER_EMULATOR_HOST" value="emulator:9010"/>

src/Schema/Builder.php

@@ -19,7 +19,10 @@
 
 use Closure;
 use Colopl\Spanner\Query\Processor;
+use Colopl\Spanner\Connection;
 use Illuminate\Database\Schema\Builder as BaseBuilder;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Fluent;
 
 /**
  * @property Grammar $grammar
@@ -46,6 +49,18 @@ public function getAllTables()
         );
     }
 
+    /**
+     * @inheritDoc
+     *
+     * @return list<array{ name: string, type: string, parent: string }>
+     */
+    public function getTables()
+    {
+        return $this->connection->select(
+            $this->grammar->compileTables()
+        );
+    }
+
     /**
      * @param string $table
      * @return string[]
@@ -64,6 +79,24 @@ public function getIndexListing($table)
         return $processor->processIndexListing($results);
     }
 
+    /**
+     * @param string $table
+     * @return string[]
+     */
+    public function getForeignListing($table)
+    {
+        $table = $this->connection->getTablePrefix().$table;
+
+        $results = $this->connection->select(
+            $this->grammar->compileForeignListing(), [$table]
+        );
+
+        /** @var Processor $processor */
+        $processor = $this->connection->getPostProcessor();
+
+        return $processor->processIndexListing($results);
+    }
+
     /**
      * @param string $table
      * @param string $name
@@ -99,4 +132,74 @@ protected function createBlueprint($table, Closure $callback = null)
             ? ($this->resolver)($table, $callback)
             : new Blueprint($table, $callback);
     }
+
+    /**
+     * Drop all tables from the database.
+     *
+     * @return void
+     */
+    public function dropAllTables()
+    {
+        /** @var Connection */
+        $connection = $this->connection;
+        $tables = self::getTables();
+        $sortedTables = [];
+
+        // get all tables
+        foreach ($tables as $table) {
+            $tableName = $table['name'];
+            $parentTableName = $table['parent'];
+
+            $sortedTables[$tableName] = [
+                'name' => $tableName,
+                'parent' => $parentTableName,
+                'parents' => 0
+            ];
+        }
+
+        // loop through all tables and count how many parents they have
+        foreach ($sortedTables as $tableName => $tableData) {
+            if(!$tableData['parent']) continue;
+
+            $current = $tableData;
+            while($current['parent']) {
+                $tableData['parents'] += 1;
+                $current = $sortedTables[$current['parent']];
+            }
+            $sortedTables[$tableName] = $tableData;
+        }
+
+        // sort tables desc based on parent count 
+        usort($sortedTables, fn($a, $b) => $b['parents'] <=> $a['parents']);
+
+        // drop foreign keys first (otherwise index queries will include them)
+        $queries = [];
+        foreach ($sortedTables as $tableData) {
+            $tableName = $tableData['name'];
+            $blueprint = new Blueprint($tableName);
+            $foreigns = self::getForeignListing($tableName);
+            foreach ($foreigns as $foreign) {
+                $column = new Fluent();
+                $column->index = $foreign;
+                $queries[] = $this->grammar->compileDropForeign($blueprint, $column);
+            }
+        }
+        $connection->runDdlBatch($queries);
+
+        // drop indexes and tables
+        $queries = [];
+        foreach ($sortedTables as $tableData) {
+            $tableName = $tableData['name'];
+            $blueprint = new Blueprint($tableName);
+            $indexes = self::getIndexListing($tableName);
+            foreach ($indexes as $index) {
+                if($index == 'PRIMARY_KEY') continue;
+                $column = new Fluent();
+                $column->index = $index;
+                $queries [] = $this->grammar->compileDropIndex($blueprint, $column);
+            }
+            $queries[] = $this->grammar->compileDrop($blueprint, new Fluent());
+        }
+        $connection->runDdlBatch($queries);
+    }
 }

src/Schema/Grammar.php

@@ -58,7 +58,7 @@ public function compileTableExists()
      */
     public function compileTables()
     {
-        return 'select `table_name` as name from information_schema.tables where table_schema = \'\' and table_type = \'BASE TABLE\'';
+        return 'select `table_name` as name, `table_type` as type, `parent_table_name` as parent from information_schema.tables where table_schema = \'\' and table_type = \'BASE TABLE\'';
     }
 
     /**
@@ -93,6 +93,16 @@ public function compileIndexListing()
         return 'select index_name as `index_name` from information_schema.indexes where table_schema = \'\' and table_name = ?';
     }
 
+    /**
+     * Compile the query to determine the list of foreign keys.
+     *
+     * @return string
+     */
+    public function compileForeignListing()
+    {
+        return 'select constraint_name as `index_name` from information_schema.table_constraints where constraint_type = "FOREIGN KEY" and table_schema = \'\' and table_name = ?';
+    }
+
     /**
      * Compile the query to determine the columns.
      *
@@ -344,6 +354,20 @@ public function compileDropUnique(Blueprint $blueprint, Fluent $command)
         return $this->compileDropIndex($blueprint, $command);
     }
 
+    /**
+     * Compile a drop foreign key command.
+     *
+     * @param  Blueprint  $blueprint
+     * @param  \Illuminate\Support\Fluent<string, mixed> $command
+     * @return string
+     */
+    public function compileDropForeign(Blueprint $blueprint, Fluent $command)
+    {
+        $index = $this->wrap($command->index);
+
+        return "alter table {$this->wrapTable($blueprint)} drop constraint {$index}";
+    }
+
     /**
      * Get the primary key syntax for a table creation statement.
      *

tests/Schema/BlueprintTest.php

@@ -193,6 +193,23 @@ public function testDropIndex(): void
         );
     }
 
+    public function testDropForeign(): void
+    {
+        $conn = $this->getDefaultConnection();
+
+        $blueprint = new Blueprint('Test3', function (Blueprint $table) {
+            $table->dropForeign('fk_test3');
+        });
+
+        $queries = $blueprint->toSql($conn, new Grammar());
+        $this->assertEquals(
+            [
+                'alter table `Test3` drop constraint `fk_test3`',
+            ],
+            $queries
+        );
+    }
+
     public function test_no_primaryKey(): void
     {
         $this->expectException(LogicException::class);

tests/Schema/BuilderTest.php → tests/Schema/BuilderTestLast.php

@@ -23,7 +23,7 @@
 use Illuminate\Support\Arr;
 use Illuminate\Support\Str;
 
-class BuilderTest extends TestCase
+class BuilderTestLast extends TestCase
 {
     private const TABLE_NAME_CREATED = 'schema_builder_test_table';
     private const TABLE_NAME_RELATION_PARENT = 'users';
@@ -243,11 +243,53 @@ public function test_getAllTables(): void
 
         /** @var array{ name: string, type: string } $row */
         $row = Arr::first(
-            $sb->getAllTables(),
+            $sb->getTables(),
             static fn (array $row): bool => $row['name'] === $table,
         );
 
         $this->assertSame($table, $row['name']);
         $this->assertSame('BASE TABLE', $row['type']);
     }
+
+    public function test_dropAllTables(): void
+    {
+        $conn = $this->getDefaultConnection();
+        $sb = $conn->getSchemaBuilder();
+        $table1 = $this->generateTableName(class_basename(__CLASS__));
+        $sb->create($table1, function (Blueprint $table) {
+            $table->uuid('id')->primary();
+            $table->uuid('something');
+            $table->index('something');
+        });
+
+        $table2 = $this->generateTableName(class_basename(__CLASS__));
+        $sb->create($table2, function (Blueprint $table) use ($table1) {
+            $table->uuid('table2_id')->primary();
+            $table->uuid('other_id');
+            $table->index('other_id');
+            $table->foreign('other_id')->references('id')->on($table1);
+        });
+
+        $table3 = $this->generateTableName(class_basename(__CLASS__));
+        $sb->create($table3, function (Blueprint $table) use ($table2) {
+            $table->uuid('table2_id');
+            $table->uuid('table3_id');
+            $table->primary(['table2_id', 'table3_id']);
+            $table->interleaveInParent($table2);
+        });
+
+        $table4 = $this->generateTableName(class_basename(__CLASS__));
+        $sb->create($table4, function (Blueprint $table) use ($table3) {
+            $table->uuid('table2_id');
+            $table->uuid('table3_id');
+            $table->uuid('table4_id');
+            $table->primary(['table2_id', 'table3_id', 'table4_id']);
+            $table->interleaveInParent($table3);
+        });
+
+        $sb->dropAllTables();
+
+        $tables = $sb->getTables();
+        $this->assertEmpty($tables);
+    }
 }