Drops the table primary key.

@throws \Fridge\DBAL\Exception\SchemaException If there is no primary key.
322154
public function dropPrimaryKey()
    {
        if (!$this->hasPrimaryKey()) {
            throw SchemaException::tablePrimaryKeyDoesNotExist($this->getName());
        }

        foreach ($this->getIndexes() as $index) {
            if ($index->hasSameColumnNames($this->getPrimaryKey()->getColumnNames())) {
                $this->dropIndex($index->getName());
            }
        }

        $this->primaryKey = null;
    }
958269
public function drop(string $table)
    {
        $compiler = $this->connection->schemaCompiler();

        $result = $compiler->drop($table);

        $this->connection->command($result['sql'], $result['params']);

        //clear table list
        $this->tableList = null;
        unset($this->columns[strtolower($table)]);
    }
1335372
public function dropSchema($schemaName)
    {
        $sql = sprintf("DROP SCHEMA IF EXISTS %s CASCADE;", $this->quoteSchemaName($schemaName));
        $this->execute($sql);
    }
1272688
function drop() {
		if( isset( $this->current_field ) ) {
			// Drop the current field
			logMsg( "Dropping field '{$this->current_field}' from table '{$this->name}'" );
			// $this->drop_field[$this->current_field] = $xmls->dict->DropColumnSQL( $this->name, $this->current_field );
			$this->drop_field[$this->current_field] = $this->current_field;
		} else {
			// Drop the current table
			logMsg( "Dropping table '{$this->name}'" );
			// $this->drop_table = $xmls->dict->DropTableSQL( $this->name );
			$this->drop_table = TRUE;
		}
	}
1343307
public void dropSchema()
    {
        if (operation != null && operation.equalsIgnoreCase("create-drop"))
        {
            try
            {
                dropKeyspaceOrCFs();
            }
            catch (Exception ex)
            {
                log.error("Error during dropping schema in cassandra, Caused by: .", ex);
                throw new SchemaGenerationException(ex, "Cassandra");
            }
        }
        cassandra_client = null;
    }
948830
public function down() {
		Schema::drop(self::TABLE_DATA);
		Schema::drop(self::TABLE);
		Schema::drop(self::TABLE_ACTION);
	}
1027970
public function dropDatabase()
    {
        $dropSchemaSql = $this->getDropDatabaseSQL();
        $conn          = $this->em->getConnection();

        foreach ($dropSchemaSql as $sql) {
            $conn->executeQuery($sql);
        }
    }
96211
public function down()
    {
        if (Schema::hasColumn('sql_db_config', 'driver')) {
            // back to pre-2.2
            Schema::table('sql_db_config', function (Blueprint $t){
                $t->string('driver')->nullable(false)->change();
                $t->string('dsn')->nullable(false)->change();
                $t->dropColumn('connection');
                $t->dropColumn('statements');
            }
            );
        }
    }
31880
public function down()
	{
        // Disable foreign key constraints or these DROPs will not work
        DB::statement('SET FOREIGN_KEY_CHECKS = 0');


		Schema::table('post_tag', function($table){
		    $table->dropIndex('post_tag_post_id_index');
		    $table->dropForeign('post_tag_post_id_foreign');
		    $table->dropIndex('post_tag_tag_id_index');
		    $table->dropForeign('post_tag_tag_id_foreign');
		});
		Schema::dropIfExists('post_tag');


		Schema::table('post_category', function($table){
		    $table->dropIndex('post_category_post_id_index');
		    $table->dropForeign('post_category_post_id_foreign');
		    $table->dropIndex('post_category_category_id_index');
		    $table->dropForeign('post_category_category_id_foreign');
		});
        Schema::dropIfExists('post_category');


		Schema::table('categories', function($table){
		    $table->dropIndex('categories_title_unique');
		    $table->dropForeign('categories_created_by_foreign');
		    $table->dropForeign('categories_updated_by_foreign');
		    $table->dropForeign('categories_locked_by_foreign');
		});
        Schema::dropIfExists('categories');


		Schema::table('tags', function($table){
		    $table->dropIndex('tags_title_unique');
		    $table->dropForeign('tags_created_by_foreign');
		    $table->dropForeign('tags_updated_by_foreign');
		    $table->dropForeign('tags_locked_by_foreign');
		});
        Schema::dropIfExists('tags');


		Schema::table('posts', function($table){
		    $table->dropIndex('posts_slug_unique');
            $table->dropIndex('posts_lookup_workflow_status_id_foreign');
            $table->dropForeign('posts_lookup_workflow_status_id_foreign');
		    $table->dropForeign('posts_created_by_foreign');
		    $table->dropForeign('posts_updated_by_foreign');
		    $table->dropForeign('posts_locked_by_foreign');
		});
        Schema::dropIfExists('posts');


		Schema::table('postupdates', function($table){
		    $table->dropForeign('postupdates_post_id_foreign');
		    $table->dropForeign('postupdates_created_by_foreign');
		    $table->dropForeign('postupdates_updated_by_foreign');
		    $table->dropForeign('postupdates_locked_by_foreign');
		});
        Schema::dropIfExists('postupdates');

        Schema::table('lookup_workflow_status', function($table){
            $table->dropIndex('lookup_workflow_status_title_unique');
            $table->dropForeign('lookup_workflow_status_created_by_foreign');
            $table->dropForeign('lookup_workflow_status_updated_by_foreign');
            $table->dropForeign('lookup_workflow_status_locked_by_foreign');
        });
        Schema::dropIfExists('lookup_workflow_status');


        // Enable foreign key constraints
        DB::statement('SET FOREIGN_KEY_CHECKS = 1');
	}
492622
public function dropAllTables()
    {
        $tables = [];

        foreach ($this->getAllTables() as $row) {
            $row = (array) $row;

            $tables[] = reset($row);
        }

        if (empty($tables)) {
            return;
        }

        $this->disableForeignKeyConstraints();

        $this->connection->statement(
            $this->grammar->compileDropAllTables($tables)
        );

        $this->enableForeignKeyConstraints();
    }
134588
public function remove(
        $table = null,
        SqlInterface $database = null,
        $primary = null
    ) {
        //if no table
        if (is_null($table)) {
            //if no default table either
            if (!$this->table) {
                //throw error
                throw SqlException::forTableNotSet();
            }

            $table = $this->table;
        }

        //if no database
        if (is_null($database)) {
            //and no default database
            if (!$this->database) {
                throw SqlException::forDatabaseNotSet();
            }

            $database = $this->database;
        }

        //get the meta data and valid columns
        $meta = $this->getMeta($table, $database);
        $data = $this->getValidColumns(array_keys($meta[self::COLUMNS]));

        if (is_null($primary)) {
            $primary = $meta[self::PRIMARY];
        }

        if (is_string($primary)) {
            $primary = [$primary];
        }

        $filter = [];
        //for each primary key
        foreach ($primary as $column) {
            //if the primary is not set
            if (!isset($data[$column])) {
                //we can't do a remove
                //do nothing more
                return $this;
            }

            //add the condition to the filter
            $filter[] = [$column.'=%s', $data[$column]];
        }

        //we delete it
        $database->deleteRows($table, $filter);

        return $this;
    }
130471
public function setPrimaryKey(PrimaryKey $primaryKey)
    {
        foreach ($primaryKey->getColumnNames() as $columnName) {
            $this->getColumn($columnName)->setNotNull(true);
        }

        $this->primaryKey = $primaryKey;
    }
1163283
public function drop()
    {

        static::valTable();
        $sql = /** @lang text */
            "DROP TABLE " . self::$table;
        try {
            $this->exec($sql);
            static::$response["status"] = "success";
            static::$response["response"] = "success";
            return self::terminate(static::$response);

        } catch (Exception $e) {
            static::$response["status"] = "error";
            static::$response["response"] = $e->getMessage();
            static::$response["code"] = $e->getCode();
            return static::terminate(static::$response);
        }

    }
1169039
public function remove($primaryKey, $secondaryKey)
    {
        unset($this->values[$primaryKey][$secondaryKey]);

        if (isset($this->values[$primaryKey]) && 0 === count($this->values[$primaryKey])) {
            unset($this->values[$primaryKey]);
        }
    }
778828
public function dropSequence($name)
    {
        if (!$this->hasSequence($name)) {
            throw SchemaException::schemaSequenceDoesNotExist($this->getName(), $name);
        }

        unset($this->sequences[$name]);
    }
1109145
public function down()
    {
        DB::statement('SET FOREIGN_KEY_CHECKS=0;');
        Schema::dropIfExists('tbl_widgets');
        Schema::dropIfExists('tbl_widget_types');
        Schema::dropIfExists('tbl_page_closure');
        Schema::dropIfExists('tbl_widgets_params');
        DB::statement('SET FOREIGN_KEY_CHECKS=1;');
    }
360151
public function down()
    {
        if ( ! $this->hasConnection()) {
            Schema::dropIfExists($this->getTableName());

            return;
        }

        Schema::connection($this->getConnection())->dropIfExists($this->getTableName());
    }