Deletes several columns by name in every row.

@param array $names List of column names to delete.
@param bool $deleteRecursiveInSubtables Whether to apply this change to all subtables or not.
12040
public function deleteColumns($names, $deleteRecursiveInSubtables = false)
    {
        foreach ($this->rows as $row) {
            foreach ($names as $name) {
                $row->deleteColumn($name);
            }
            $subTable = $row->getSubtable();
            if ($subTable) {
                $subTable->deleteColumns($names, $deleteRecursiveInSubtables);
            }
        }
        if (!is_null($this->summaryRow)) {
            foreach ($names as $name) {
                $this->summaryRow->deleteColumn($name);
            }
        }
        if (!is_null($this->totalsRow)) {
            foreach ($names as $name) {
                $this->totalsRow->deleteColumn($name);
            }
        }
    }
778828
public function dropSequence($name)
    {
        if (!$this->hasSequence($name)) {
            throw SchemaException::schemaSequenceDoesNotExist($this->getName(), $name);
        }

        unset($this->sequences[$name]);
    }
139181
public function delete($name)
    {
        if ($this->cookies[$name]) {
            unset($this->cookies[$name]);

            return true;
        }

        return false;
    }
481327
public function setOrder(array $names): bool
    {
        $order = array_flip($this->parseNames($names));
        if ($this->order === $order) {
            return false;
        }
        $this->order = $order;
        $this->count = count($order);
        return true;
    }
1157309
protected function deleteRecord($name)
    {
        try {
            return (bool) $this->db
                    ->from($this->table)
                    ->where($this->columns['name'])->eq($name)
                    ->delete();
        } catch (PDOException $e) {
            return false;
        }
    }
563559
protected function deleteMigrations(array $migrations)
	{
		if ( !$migrations ) {
			return;
		}

		$sql = 'DELETE FROM Migrations
				WHERE Name IN (:names)';
		$this->_context->getDatabase()->perform($sql, array('names' => $migrations));
	}
932344
public static function offMulti(array $names)
    {
        foreach ($names as $value) {
            list($class, $name) = $value;
            static::off($class, $name);
        }
    }
241077
public function dropColumn( $table, $name )
    {
        try
        {
            $tmpTable = $table . '_old';

            $this->startTransaction();

            $this->copyTable( $table, $tmpTable, [ $name ] );

            $this->dropTable( $tmpTable );

            $this->commitTransaction();
        }
        catch ( Exception $e )
        {
            $this->rollbackTransaction();

            return FALSE;
        }

        return TRUE;
    }
556616
public function setRemovedColumns(array $removedColumns)
    {
        $this->removedColumns = [];
        foreach ($removedColumns as $removedColumn) {
            $this->addRemovedColumn($removedColumn->getName(), $removedColumn);
        }
    }
665172
public function dropCheck($name)
    {
        if (!$this->hasCheck($name)) {
            throw SchemaException::tableCheckDoesNotExist($this->getName(), $name);
        }

        unset($this->checks[$name]);
    }
987915
public function deleteTable($name)
    {
        try {
            $this->_tableProxy->deleteTable($name);

            return true;
        } catch (\Exception $ex) {
            return false;
        }
    }
889282
public function delete(int $fd, $roomNames = [])
    {
        $allRooms = $this->getRooms($fd);
        $roomNames = is_array($roomNames) ? $roomNames : [$roomNames];
        $rooms = count($roomNames) ? $roomNames : $allRooms;

        $removeRooms = [];
        foreach ($rooms as $room) {
            $fds = $this->getClients($room);

            if (! in_array($fd, $fds)) {
                continue;
            }

            $this->setClients($room, array_values(array_diff($fds, [$fd])));
            $removeRooms[] = $room;
        }

        $this->setRooms($fd, collect($allRooms)->diff($removeRooms)->values()->toArray());
    }
749422
public static function setNames(array $names)
    {
        if(static::$isInited)
        {
            throw new \RuntimeException('addName failed, ChannelManager was inited');
        }
        foreach($names as $key => $args)
        {
            static::$channels[$key] = $args;
        }
    }
699484
public function dropTable($name)
    {
        if (!$this->hasTable($name)) {
            throw SchemaException::schemaTableDoesNotExist($this->getName(), $name);
        }

        unset($this->tables[$name]);
    }
1213854
public function removeChild($name)
    {
        foreach ($this->children as $key => $child) {
            if ($child->appliesTo($name) === true) {
                unset($this->children[$key]);
                $this->updateModifications();
                return true;
            }
        }

        return false;
    }
1208941
public function delete($fieldsValues)
    {
        $this->connectToDB();
        $this->queryBuilder->table($this->table());
        $this->queryBuilder->delete($fieldsValues);
    }
77471
public function removeItem(string $name, $removeChildren = true)
    {
        if ($removeChildren) {
            if ($item = $this->getItem($name)) {
                $item->children()->each(function ($item) {
                    $this->removeItem($item->name);
                });
            }
        }

        return $this->items->remove($name);
    }