studio - ¿Cómo verifico en SQLite si existe una tabla?

sqlite studio

Question

¿Cómo, de forma confiable , verifico en SQLite, si existe una tabla de usuario en particular?

No estoy pidiendo formas poco confiables, como verificar si un "seleccionar *" en la tabla devolvió un error o no (¿es esto incluso una buena idea?).

La razón es así:

En mi programa, necesito crear y luego rellenar algunas tablas si aún no existen.

Si ya existen, necesito actualizar algunas tablas.

¿Debo tomar otra ruta para indicar que las tablas en cuestión ya se han creado? Por ejemplo, al crear / poner / configurar una marca determinada en mi archivo de configuración / inicialización de programa en el disco o algo así

¿O tiene sentido mi enfoque?

Answer 1

Aquí está la función que utilicé:

Dado un objeto de base de datos SQL = db

public boolean exists(String table) {
    try {
         db.query("SELECT * FROM " + table);
         return true;
    } catch (SQLException e) {
         return false;
    }
}

Answer 2

El siguiente código devuelve 1 si la tabla existe o 0 si la tabla no existe.

SELECT CASE WHEN tbl_name = "name" THEN 1 ELSE 0 END FROM sqlite_master WHERE tbl_name = "name" AND type = "table"

Answer 3

Este es mi código para SQLite Cordova:

get_columnNames(''LastUpdate'', function (data) {
    if (data.length > 0) { // In data you also have columnNames
        console.log("Table full");
    }
    else {
        console.log("Table empty");
    }
});

Y el otro:

function get_columnNames(tableName, callback) {
    myDb.transaction(function (transaction) {
        var query_exec = "SELECT name, sql FROM sqlite_master WHERE type=''table'' AND name =''" + tableName + "''";
        transaction.executeSql(query_exec, [], function (tx, results) {
            var columnNames = [];
            var len = results.rows.length;
            if (len>0){
                var columnParts = results.rows.item(0).sql.replace(/^[^/(]+/(([^/)]+)/)/g, ''$1'').split('',''); ///// RegEx
                for (i in columnParts) {
                    if (typeof columnParts[i] === ''string'')
                        columnNames.push(columnParts[i].split(" ")[0]);
                };
                callback(columnNames);
            }
            else callback(columnNames);
        });
    });
}

Answer 4

Los nombres de tablas de SQLite no distinguen entre mayúsculas y minúsculas, pero la comparación es sensible a mayúsculas y minúsculas de forma predeterminada Para que esto funcione correctamente en todos los casos, debe agregar COLLATE NOCASE .

SELECT name FROM sqlite_master WHERE type=''table'' AND name=''table_name'' COLLATE NOCASE

Answer 5

Me perdí esa entrada de preguntas frecuentes.

De todos modos, para futuras referencias, la consulta completa es:

SELECT name FROM sqlite_master WHERE type=''table'' AND name=''{table_name}'';

Donde {table_name} es el nombre de la tabla para verificar.

Sección de documentación para referencia: Formato de archivo de base de datos. 2.6. Almacenamiento del esquema de base de datos SQL

Answer 6

Pensé que pondría mis 2 centavos en esta discusión, incluso si es bastante antigua. Esta consulta devuelve el escalar 1 si la tabla existe y 0 de lo contrario

select 
    case when exists 
        (select 1 from sqlite_master WHERE type=''table'' and name = ''your_table'') 
        then 1 
        else 0 
    end as TableExists

Answer 7

Puede escribir la siguiente consulta para verificar la existencia de la tabla.

SELECT name FROM sqlite_master WHERE name=''table_name''

Aquí ''table_name'' es el nombre de la tabla que creaste. Por ejemplo

 CREATE TABLE IF NOT EXISTS country(country_id INTEGER PRIMARY KEY AUTOINCREMENT, country_code TEXT, country_name TEXT)"

y comprobar

  SELECT name FROM sqlite_master WHERE name=''country''

Answer 8

Si está utilizando SQLite versión 3.3+, puede crear fácilmente una tabla con:

create table if not exists TableName (col1 typ1, ..., colN typN)

De la misma manera, puede eliminar una tabla solo si existe utilizando:

drop table if exists TableName

Answer 9

Si estás usando fmdb , creo que puedes importar FMDatabaseAdditions y usar la función bool:

[yourfmdbDatabase tableExists:tableName].

Answer 10

Si obtiene un error de "tabla ya existe", realice los cambios en la cadena SQL como se muestra a continuación:

CREATE table IF NOT EXISTS table_name (para1,para2);

De esta manera podrás evitar las excepciones.

Answer 11

Tenga en cuenta que para verificar si existe una tabla en la base de datos TEMP, debe usar sqlite_temp_master lugar de sqlite_master :

SELECT name FROM sqlite_temp_master WHERE type=''table'' AND name=''table_name'';

Answer 12

Tu podrías intentar:

SELECT name FROM sqlite_master WHERE name=''table_name''

Answer 13

Una variación sería usar SELECT COUNT (*) en lugar de SELECT NAME, es decir,

SELECT count(*) FROM sqlite_master WHERE type=''table'' AND name=''table_name'';

Esto devolverá 0, si la tabla no existe, 1 si existe. Probablemente esto sea útil en su programación, ya que un resultado numérico es más rápido / más fácil de procesar. Lo siguiente ilustra cómo haría esto en Android utilizando SQLiteDatabase, Cursor, rawQuery con parámetros.

boolean tableExists(SQLiteDatabase db, String tableName)
{
    if (tableName == null || db == null || !db.isOpen())
    {
        return false;
    }
    Cursor cursor = db.rawQuery("SELECT COUNT(*) FROM sqlite_master WHERE type = ? AND name = ?", new String[] {"table", tableName});
    if (!cursor.moveToFirst())
    {
        cursor.close();
        return false;
    }
    int count = cursor.getInt(0);
    cursor.close();
    return count > 0;
}

Answer 14

Usa este código:

SELECT name FROM sqlite_master WHERE type=''table'' AND name=''yourTableName'';

Si el recuento de matriz devuelto es igual a 1, significa que la tabla existe. De lo contrario no existe.

Answer 15

Usar una consulta SELECT simple es, en mi opinión, bastante confiable. Más que nada, puede verificar la existencia de tablas en diferentes tipos de bases de datos (SQLite / MySQL).

SELECT 1 FROM table;

Tiene sentido cuando puede usar otro mecanismo confiable para determinar si la consulta tuvo éxito (por ejemplo, consulta una base de datos a través de QSqlQuery en Qt ).

Answer 16

Utilizar

SELECT 1 FROM table LIMIT 1;

para evitar que todos los registros sean leídos.

Answer 17

Utilizar:

PRAGMA table_info(your_table_name)

Si la tabla resultante está vacía, tu your_table_name no existe.

Documentación:

PRAGMA schema.table_info (nombre-tabla);

Este pragma devuelve una fila para cada columna en la tabla nombrada. Las columnas en el conjunto de resultados incluyen el nombre de la columna, el tipo de datos, si la columna puede ser NULL o no, y el valor predeterminado para la columna. La columna "pk" en el conjunto de resultados es cero para las columnas que no forman parte de la clave principal, y es el índice de la columna en la clave principal para las columnas que forman parte de la clave principal.

La tabla nombrada en el pragma table_info también puede ser una vista.

Ejemplo de salida:

cid|name|type|notnull|dflt_value|pk
0|id|INTEGER|0||1
1|json|JSON|0||0
2|name|TEXT|0||0

Answer 18

Ver this

SELECT name FROM sqlite_master
WHERE type=''table''
ORDER BY name;