Drop model and table from database.

        >> migrator.drop_table(model, cascade=True)
177023
def drop_table(self, model, cascade=True):
        
        del self.orm[model._meta.table_name]
        self.ops.append(self.migrator.drop_table(model, cascade))
218486
def drop_db():
    """"""
    local_machine()
    with fab_settings(warn_only=True):
        local('psql {0} -c "DROP DATABASE {1}"'.format(
            USER_AND_HOST, env.db_name))
        local('psql {0} -c "DROP USER {1}"'.format(
            USER_AND_HOST, env.db_role))
196873
def drop(self):
        
        api = self._instance._client.database_admin_api
        metadata = _metadata_with_prefix(self.name)
        api.drop_database(self.name, metadata=metadata)
99198
def drop(self):
        
        Statement = self.get_model('statement')
        Tag = self.get_model('tag')

        session = self.Session()

        session.query(Statement).delete()
        session.query(Tag).delete()

        session.commit()
        session.close()
955695
def drop_schema(client, table_name):
        
        query = 'DROP TABLE {cf}'
        return client.execute(query.format(cf=table_name),
                              {}, ConsistencyLevel.QUORUM)
1094114
def drop_column(self, name):
        
        self._check_dropped()
        if name in list(self.table.columns.keys()):
            self.op.drop_column(self.table.name, name, schema=self.schema)
            self.table = self._update_table(self.table.name)
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)
43241
def drop_all_tables(self):
        """"""
        for table_name in self.table_names():
            self.execute_sql("DROP TABLE %s" % table_name)
        self.connection.commit()
309031
def drop_table(self, table):
        
        job_id = self.submit("DROP TABLE %s"%table, context="MYDB")
        status = self.monitor(job_id)
        if status[0] != 5:
            raise Exception("Couldn't drop table %s"%table)
134485
def _drop_tables(self):
        
        drop_cmd = "DROP TABLE IF EXISTS {};"
        for table in [self.subdomain_table, self.blocked_table]:
            cursor = self.conn.cursor()
            db_query_execute(cursor, drop_cmd.format(table), ())
1027970
public function dropDatabase()
    {
        $dropSchemaSql = $this->getDropDatabaseSQL();
        $conn          = $this->em->getConnection();

        foreach ($dropSchemaSql as $sql) {
            $conn->executeQuery($sql);
        }
    }
430621
def cascade_delete(self, name):
    ""
    for child in self[name].child_tables:
      self.cascade_delete(child.name)
    del self[name]
20727
def drop(self, force=False):
        
        self.client.drop_database(self.name, force=force)
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.')
536980
protected function dropTable()
    {
        try {
            if ($this->db->schema->getTableSchema($this->table, true) !== null) {
                $this->db->createCommand()->dropTable($this->table)->execute();
                return $this->returnWarning(Yii::t('podium/flash', 'Table {name} has been dropped', ['name' => $this->rawTable]));
            }
            return true;
        } catch (Exception $e) {
            return $this->returnError($e->getMessage(), __METHOD__,
                Yii::t('podium/flash', 'Error during table {name} dropping', [
                    'name' => $this->rawTable
                ])
            );
        }
    }
1300785
def _drop(self, tree):
        
        tablename = tree.table
        kwargs = {}
        try:
            ret = self.connection.delete_table(tablename, **kwargs)
        except DynamoDBError as e:
            if e.kwargs["Code"] == "ResourceNotFoundException" and tree.exists:
                return False
            raise
        return True