Comando Soltar todas las tablas

¿Cuál es el comando para eliminar todas las tablas en SQLite?

Del mismo modo, me gustaría eliminar todos los índices.

No creo que pueda eliminar todas las tablas de un solo golpe, pero puede hacer lo siguiente para obtener los comandos:

select 'drop table ' || name || ';' from sqlite_master
    where type = 'table';

El resultado de esto es un script que le quitará las tablas. Para índices, simplemente reemplace table con index.

Puede utilizar otras cláusulas en la wheresección para limitar qué tablas o índices se seleccionan (como " and name glob 'pax_*'" para los que comienzan con "pax_").

Puede combinar la creación de este script con su ejecución en un script bash (o cmd.exe) simple para que solo haya un comando para ejecutar.

Si no se preocupan por cualquiera de la información en la base de datos, creo que sólo se puede eliminar el archivo se almacena en el disco duro fuera - que es probablemente más rápido. Nunca he probado esto, pero no veo por qué no funcionaría.

Si bien es cierto que no existe el comando DROP ALL TABLES, puede usar el siguiente conjunto de comandos.

Nota: Estos comandos tienen el potencial de dañar su base de datos, así que asegúrese de tener una copia de seguridad.

PRAGMA writable_schema = 1;
delete from sqlite_master where type in ('table', 'index', 'trigger');
PRAGMA writable_schema = 0;

luego desea recuperar el espacio eliminado con

VACUUM;

y una buena prueba para asegurarse de que todo esté bien

PRAGMA INTEGRITY_CHECK;

rm db/development.sqlite3

Tuve el mismo problema con SQLite y Android. Aquí está mi solución:

List<String> tables = new ArrayList<String>();
Cursor cursor = db.rawQuery("SELECT * FROM sqlite_master WHERE type='table';", null);
cursor.moveToFirst();
while (!cursor.isAfterLast()) {
    String tableName = cursor.getString(1);
    if (!tableName.equals("android_metadata") &&
            !tableName.equals("sqlite_sequence"))
        tables.add(tableName);
    cursor.moveToNext();
}
cursor.close();

for(String tableName:tables) {
    db.execSQL("DROP TABLE IF EXISTS " + tableName);
}

Me gustaría agregar a otras respuestas que implican eliminar tablas y no eliminar el archivo, que también puede ejecutar delete from sqlite_sequencepara restablecer las secuencias de incremento automático.

Una vez que haya eliminado todas las tablas (y los índices desaparecerán cuando la tabla se vaya), no queda nada en una base de datos SQLite que yo sepa, aunque el archivo no parece encogerse (de una prueba rápida que acabo de hacer ).

Por lo tanto, eliminar el archivo parecería ser más rápido; simplemente debería volver a crearse cuando su aplicación intente acceder al archivo db.

Usando pysqlite:

tables = list(cur.execute("select name from sqlite_master where type is 'table'"))

cur.executescript(';'.join(["drop table if exists %s" %i for i in tables]))

Tuve este problema en Android y escribí un método similar a it-west.

Debido a que usé AUTOINCREMENTclaves primarias en mis tablas, hubo una tabla llamada sqlite_sequence. SQLite se bloqueaba cuando la rutina intentaba eliminar esa tabla. Tampoco pude captar la excepción. Mirando https://www.sqlite.org/fileformat.html#internal_schema_objects , descubrí que podría haber varias de estas tablas de esquemas internos que no quería eliminar. La documentación dice que cualquiera de estas tablas tiene nombres que comienzan con sqlite_ así que escribí este método

private void dropAllUserTables(SQLiteDatabase db) {
    Cursor cursor = db.rawQuery("SELECT name FROM sqlite_master WHERE type='table'", null);
    //noinspection TryFinallyCanBeTryWithResources not available with API < 19
    try {
        List<String> tables = new ArrayList<>(cursor.getCount());

        while (cursor.moveToNext()) {
            tables.add(cursor.getString(0));
        }

        for (String table : tables) {
            if (table.startsWith("sqlite_")) {
                continue;
            }
            db.execSQL("DROP TABLE IF EXISTS " + table);
            Log.v(LOG_TAG, "Dropped table " + table);
        }
    } finally {
        cursor.close();
    }
}

No puedo decir que esta sea la solución más portátil o a prueba de balas, pero funciona para mis scripts de prueba:

.output /tmp/temp_drop_tables.sql
select 'drop table ' || name || ';' from sqlite_master where type = 'table';
.output stdout
.read /tmp/temp_drop_tables.sql
.system rm /tmp/temp_drop_tables.sql

Este fragmento de código redirige la salida a un archivo temporal, construye los comandos de 'drop table' que quiero ejecutar (enviando los comandos al archivo temporal), establece la salida de nuevo a la salida estándar, luego ejecuta los comandos del archivo y finalmente elimina el archivo.

O en un indicador de shell, en solo dos líneas, sin un archivo temporal con nombre, asumiendo que $ db es el nombre de la base de datos SQLite:

echo "SELECT 'DROP TABLE ' || name ||';' FROM sqlite_master WHERE type = 'table';" |
    sqlite3 -readonly "$db" | sqlite3 "$db"