Drop the column ``name``.
        ::
            table.drop_column('created_at')
331813
def drop_column(self, name):
        
        if self.db.engine.dialect.name == 'sqlite':
            raise RuntimeError("SQLite does not support dropping columns.")
        name = normalize_column_name(name)
        with self.db.lock:
            if not self.exists or not self.has_column(name):
                log.debug("Column does not exist: %s", name)
                return

            self._threading_warn()
            self.db.op.drop_column(
                self.table.name,
                name,
                self.table.schema
            )
            self._reflect_table()
240165
def delete_table(cls):
        
        schema_editor = getattr(connection, 'schema_editor', None)
        if schema_editor:
            with connection.schema_editor() as schema_editor:
                schema_editor.delete_model(cls)
        else:
            cursor = connection.cursor()
            try:
                with warnings.catch_warnings():
                    warnings.filterwarnings('ignore', 'unknown table')
                    cursor.execute('DROP TABLE IF EXISTS {0}'.format(cls._meta.db_table))
            finally:
                cursor.close()
177023
def drop_table(self, model, cascade=True):
        
        del self.orm[model._meta.table_name]
        self.ops.append(self.migrator.drop_table(model, cascade))
1333575
def drop_field(app_name, model_name, field_name):
    
    app_config = apps.get_app_config(app_name)
    model = app_config.get_model(model_name)
    field = model._meta.get_field(field_name)
    with connection.schema_editor() as schema_editor:
        schema_editor.remove_field(model, field)
770294
def delete_table(self, tablename):
        
        self.tables = filter(lambda x: x.name != tablename, self.tables)
502226
public <T> void dropColumn(Attribute<T, ?> attribute) {
        Type<T> type = attribute.getDeclaringType();
        if (attribute.isForeignKey()) {
            // TODO MySQL need to drop FK constraint first
        }
        QueryBuilder qb = createQueryBuilder();
        qb.keyword(ALTER, TABLE)
            .tableName(type.getName())
            .keyword(DROP, COLUMN)
            .attribute(attribute);
        try (Connection connection = getConnection()) {
            executeSql(connection, qb);
        } catch (SQLException e) {
            throw new TableModificationException(e);
        }
    }
25631
def keep(self, keep_names):
        """"""
        
        current_names = self._data.columns
        drop_names = []
        for name in current_names:
            if name not in keep_names:
                drop_names.append(name)
        self.drop(drop_names)
967822
def drop(self, *cols):
        
        try:
            index = self.df.columns.values
            for col in cols:
                if col not in index:
                    self.warning("Column", col, "not found. Aborting")
                    return
                self.df = self.df.drop(col, axis=1)
        except Exception as e:
            self.err(e, self.drop, "Can not drop column")
435300
def drop(self):
        
        if self.restriction:
            raise DataJointError('A relation with an applied restriction condition cannot be dropped.'
                                 ' Call drop() on the unrestricted Table.')
        self.connection.dependencies.load()
        do_drop = True
        tables = [table for table in self.connection.dependencies.descendants(self.full_table_name)
                  if not table.isdigit()]
        if config['safemode']:
            for table in tables:
                print(table, '(%d tuples)' % len(FreeTable(self.connection, table)))
            do_drop = user_choice("Proceed?", default='no') == 'yes'
        if do_drop:
            for table in reversed(tables):
                FreeTable(self.connection, table).drop_quick()
            print('Tables dropped.  Restart kernel.')
649017
void processAlterTableDropColumn(Table table, String colName,
                                     boolean cascade) {

        int colindex = table.getColumnIndex(colName);

        if (table.getColumnCount() == 1) {
            throw Error.error(ErrorCode.X_42591);
        }

        session.commit(false);

        TableWorks tableWorks = new TableWorks(session, table);

        tableWorks.dropColumn(colindex, cascade);

        //VoltDB extension to support Time to live
        if (table.getTTL() != null && colName.equalsIgnoreCase(table.getTTL().ttlColumn.getName().name)) {
            table.dropTTL();
        }
    }
1146323
def drop_table_or_view(self, name, database=None, force=False):
        
        try:
            self.drop_table(name, database=database)
        except Exception as e:
            try:
                self.drop_view(name, database=database)
            except Exception:
                raise e
1148540
def drop_table(self, table_name):
        

        self.validate_access_permission(["w", "a"])

        if table_name in SQLITE_SYSTEM_TABLES:
            # warning message
            return

        if self.has_table(table_name):
            query = "DROP TABLE IF EXISTS '{:s}'".format(table_name)
            self.execute_query(query, logging.getLogger().findCaller())
            self.commit()
249052
def drop_column(self, tablename: str, fieldname: str) -> int:
        """"""
        sql = "ALTER TABLE {} DROP COLUMN {}".format(tablename, fieldname)
        log.info(sql)
        return self.db_exec_literal(sql)
926515
def do_drop(self, line):
        ""
        self.conn.delete_table(self.conn.get_table(line))
630078
def delete_table(self, table_name):
        
        data = {'TableName': table_name}
        json_input = json.dumps(data)
        return self.make_request('DeleteTable', json_input)
1126346
protected function dropColumn(string $tableName, string $column) : void
    {
        // Check for its existence before dropping
        if (! $this->schema->hasColumn($tableName, $column)) {
            return;
        }

        $this->schema->table($tableName, function (Blueprint $table) use ($column) {
            $table->dropColumn($column);
        });
    }
1026147
def drop(self, table):
        
        existing_tables = self.tables
        if isinstance(table, (list, set, tuple)):
            for t in table:
                self._drop(t, existing_tables)
        else:
            self._drop(table, existing_tables)
        return table