Returns the SQL snippet to drop an existing table.

        :param table: The table
        :type table: Table or str

        :rtype: str
424307
def get_drop_table_sql(self, table):
        
        if isinstance(table, Table):
            table = table.get_quoted_name(self)

        return "DROP TABLE %s" % table
531168
def table(tab):
    
    global open_tables
    if tab in open_tables:
        yield open_tables[tab]
    else:
        open_tables[tab] = iptc.Table(tab)
        open_tables[tab].refresh()
        open_tables[tab].autocommit = False
        yield open_tables[tab]
        open_tables[tab].commit()
        del open_tables[tab]
449837
def delete(self, table, where=None, commit=True):
        
        where_q, _args = self._where_parser(where)

        alias = self._tablename_parser(table)['alias']

        _sql = ''.join(['DELETE ',
                        alias + ' ' if alias else '',
                        'FROM ', self._tablename_parser(table)['formatted_tablename'], where_q, ';'])

        if self.debug:
            return self.cur.mogrify(_sql, _args)

        result = self.cur.execute(_sql, _args)
        if commit:
            self.commit()
        return result
189734
def delete(self):
        
        cmd = "delete from {table} {where_clause}".format(
            table=self.table_name,
            where_clause=self.where_clause
        ).rstrip()
        Repo.db.execute(cmd, self.where_values)
63996
@NonNull
  public static Drop dropTable(@NonNull String tableName) {
    return dropTable(CqlIdentifier.fromCql(tableName));
  }
583223
public function dropAndCreateTable(Table $table)
    {
        $this->tryMethod('dropTable', $table->getQuotedName($this->_platform));
        $this->createTable($table);
    }
230999
def drop(self, table_names):
        '''
        
        '''
        table_names = self._check_table_names(table_names)

        for tname in table_names:
            tname = self._check_tname(tname, noload=True)

            # Warning: if auto_load is on the next insert will re-create the table
            with self._lock:
                del self._db[tname]

                filepath = os.path.join(self.root_dir, self.name, tname + '.csv')
                if self.persistent and os.path.exists(filepath):
                    try:
                        os.remove(filepath)
                        self._print('Drop %s: Success' % tname)
                    except (IOError, WindowsError):
                        self._print('Drop %s: Failed' % tname)
1048370
def load_table(self, table):
        
        table = self._valid_table_name(table)
        schema, table = self.parse_table_name(table)
        if not schema:
            schema = self.schema
            tables = self.tables
        else:
            tables = self.tables_in_schema(schema)
        if table in tables:
            return Table(self, schema, table)
        else:
            return None
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()
425299
def drop_table(self, cursor, target, options):
        ""
        sql = 'DROP TABLE IF EXISTS {0}'
        cursor.execute(sql.format(self.qualified_names[target]))
12011
public function drop($table = '')
    {
        $tableName = '';

        $tableName = ($table !== '') ?
            $table : $this->tableName;

        $this->schema = strtoupper(__FUNCTION__).' TABLE IF EXISTS
        `'.$this->database.'`.`'.$tableName.'`'.PHP_EOL;

        return $this;
    }
1329015
def __dumptable(self, table):
        
        for x in table.table.keys():
            sys.stdout.write("{0}\t<--- {1} {2}".format(x, table[x], type(table[x])))
            if isinstance(table[x], ID):
                sys.stdout(" {0}".format(table[x].value)),
            sys.stdout.write("\n")
84826
def remove(self):
        
        ''' 
                
        '''
        
        self.table.drop(self.engine)
        
        exit_msg = '%s table has been removed from %s database.' % (self.table_name, self.database_name)
        self.printer(exit_msg)
        
        return exit_msg
595246
public function dropTable($table)
    {
        $table = $this->buildRealTableName($table);
        $sql = $this->getSchema()->getDropTableSql($table);
        $ret = $this->query($sql);
        return $ret;
    }
1199562
public static Truncate truncate(@NonNull String table) {
    return truncate(null, CqlIdentifier.fromCql(table));
  }
1262936
def drop_table(self, model_class):
        '''
        
        '''
        if model_class.is_system_model():
            raise DatabaseException("You can't drop system table")
        self._send(model_class.drop_table_sql(self))