Drop a table from the schema.

        :param table: The table
        :type table: str
161620
def drop_if_exists(self, table):
        
        blueprint = self._create_blueprint(table)

        blueprint.drop_if_exists()

        self._build(blueprint)
936367
def delete_table(self, table):
        
        response = self.layer1.delete_table(table.name)
        table.update_from_response(response)
306832
public void removeTable(final Table table) {
        final List<Column> columns = table.getColumns();
        for (final Column column : columns) {
            _analysisJobBuilder.removeSourceColumn(column);
        }
    }
726886
@Override
    public void dropSchema()
    {
        for (TableInfo tableInfo : tableInfos)
        {
            try
            {
                client.deleteTable(tableInfo.getTableName());
            }
            catch (Exception ex)
            {
                logger.error("Error during deleting tables in kudu, Caused by: ", ex);
                throw new SchemaGenerationException(ex, "Kudu");
            }
        }
    }
532869
def remove_column(table, remove_index):
        '''
        
        '''
        for row_index in range(len(table)):
            old_row = table[row_index]
            new_row = []
            for column_index in range(len(old_row)):
                if column_index != remove_index:
                    new_row.append(old_row[column_index])
            table[row_index] = new_row
        return table
1172951
@NonNull
  public static DeleteSelection deleteFrom(@NonNull String table) {
    return deleteFrom(CqlIdentifier.fromCql(table));
  }
974524
def delete_table(table_name):
    """"""
    to_delete = [
        make_key(table_name, rec['id'])
        for rec in read_by_indexes(table_name, [])
    ]

    with DatastoreTransaction() as tx:
        tx.get_commit_req().mutation.delete.extend(to_delete)
262397
public void dropTable(Type<?> type) {
        try (Connection connection = getConnection();
             Statement statement = connection.createStatement()) {
            executeDropStatements(statement, Collections.<Type<?>>singletonList(type));
        } catch (SQLException e) {
            throw new TableModificationException(e);
        }
    }
824098
@SafeVarargs
  public static void drop(Table... tables) {
    foreach(tables, 
        (callInfo, table) -> DBSetup.drop(callInfo, table.getDB(), table.getName()), 
        CallInfo.create());
  }
1058275
def drop_schema(self):
        """"""
        execute = self.cursor.execute
        execute('DROP TABLE IF EXISTS gauged_data')
        execute('DROP TABLE IF EXISTS gauged_keys')
        execute('DROP TABLE IF EXISTS gauged_writer_history')
        execute('DROP TABLE IF EXISTS gauged_cache')
        execute('DROP TABLE IF EXISTS gauged_statistics')
        execute('DROP TABLE IF EXISTS gauged_metadata')
        self.db.commit()
1123451
def drop_schema(self, schema, cascade=False):
        
        if schema in self.schemas:
            sql = "DROP SCHEMA " + schema
            if cascade:
                sql = sql + " CASCADE"
            self.execute(sql)
254973
async def delete(self):
        
        await r.table_name(self.table_name) \
            .get(self.id) \
            .delete() \
            .run(await conn.get())
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))
396776
public function dropTable($table)
    {
        $changeSetElt = $this->createChangeSet('drop-table-' . $table->getName());
        $dropTableElt = $this->document->createElement('dropTable');

        $tableName = QualifiedName::fromAsset($table);

        if ($tableName->getNamespaceName()) {
            $dropTableElt->setAttribute('schemaName', $tableName->getNamespaceName());
        }
        $dropTableElt->setAttribute('tableName', $tableName->getName());
        // Should we add cascadeConstraints attribute ?
        // $dropTableElt->setAttribute('cascadeConstraints', 'false');

        $changeSetElt->appendChild($dropTableElt);
        $this->root->appendChild($changeSetElt);
    }
601383
public function dropExistingTable($table)
    {
        echo "    > drop table $table if exists ...";
        $time = microtime(true);
        $this->db->createCommand('DROP TABLE IF EXISTS `' . $table . '`')->execute();
        echo " done (time: " . sprintf('%.3f', microtime(true) - $time) . "s)\n";
    }
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)
878249
def truncate_table(self, table):
        
        table = table.get_soap_object(self.client)
        return self.call('truncateTable', table)