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

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

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

La razón es así:

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

Si ya existen, necesito actualizar algunas tablas.

¿Debería tomar otra ruta para indicar que las tablas en cuestión ya se han creado, por ejemplo, creando / colocando / configurando un determinado indicador en el archivo de configuración / inicialización de mi programa en el disco o algo así?

¿O mi enfoque tiene sentido?

Me perdí esa entrada de preguntas frecuentes.

De todos modos, para referencia futura, la consulta completa es:

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

¿Dónde {table_name}está 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

• Esto devolverá una lista de tablas con el nombre especificado; es decir, el cursor tendrá un recuento de 0 (no existe) o un recuento de 1 (sí existe)

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)

Del mismo modo, puede eliminar una tabla solo si existe mediante el uso de:

drop table if exists TableName

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. Esto probablemente sea útil en su programación ya que un resultado numérico es más rápido / fácil de procesar. Lo siguiente ilustra cómo haría esto en Android usando 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;
}

Tu podrías intentar:

SELECT name FROM sqlite_master WHERE name='table_name'

Utilizar:

PRAGMA table_info(your_table_name)

Si la tabla resultante está vacía, entonces your_table_nameno existe.

Documentación:

PRAGMA schema.table_info (nombre-tabla);

Este pragma devuelve una fila para cada columna en la tabla con nombre. 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 primaria, y es el índice de la columna en la clave primaria para las columnas que forman parte de la clave primaria.

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

Salida de ejemplo:

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

Los nombres de tabla de SQLite no distinguen entre mayúsculas y minúsculas, pero la comparación distingue entre 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

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

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

De esta manera puede evitar las excepciones.

Mira esto :

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

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

[yourfmdbDatabase tableExists:tableName].

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"

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

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

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

Dado un objeto SQLDatabase = db

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

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.

class CPhoenixDatabase():
    def __init__(self, dbname):
        self.dbname = dbname
        self.conn = sqlite3.connect(dbname)

    def is_table(self, table_name):
        """ This method seems to be working now"""
        query = "SELECT name from sqlite_master WHERE type='table' AND name='{" + table_name + "}';"
        cursor = self.conn.execute(query)
        result = cursor.fetchone()
        if result == None:
            return False
        else:
            return True

Nota: Esto está funcionando ahora en mi Mac con Python 3.7.1

Utilizar

SELECT 1 FROM table LIMIT 1;

para evitar que se lean todos los registros.

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

SELECT name FROM sqlite_master WHERE name='table_name'

Aquí 'nombre_tabla' es el nombre de la tabla que creó. Por ejemplo

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

y verifica

  SELECT name FROM sqlite_master WHERE name='country'

La forma más confiable que he encontrado en C # en este momento, usando el último paquete nuget sqlite-net-pcl (1.5.231) que está usando SQLite 3, es la siguiente:

var result = database.GetTableInfo(tableName);
if ((result == null) || (result.Count == 0))
{
    database.CreateTable<T>(CreateFlags.AllImplicit);
}

Usar una simple consulta SELECT es, en mi opinión, bastante confiable. Sobre todo, puede verificar la existencia de tablas en muchos tipos de bases de datos diferentes (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 ).

La función c ++ comprueba db y todas las bases de datos adjuntas para ver si existen tablas y columnas (opcionalmente)

bool exists(sqlite3 *db, string tbl, string col="1")
{
    sqlite3_stmt *stmt;
    bool b = sqlite3_prepare_v2(db, ("select "+col+" from "+tbl).c_str(),
    -1, &stmt, 0) == SQLITE_OK;
    sqlite3_finalize(stmt);
    return b;
}

Editar: Recientemente descubrí la función sqlite3_table_column_metadata. Por lo tanto

bool exists(sqlite3* db,const char *tbl,const char *col=0)
{return sqlite3_table_column_metadata(db,0,tbl,col,0,0,0,0,0)==SQLITE_OK;}

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);
        });
    });
}

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 en caso contrario.

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

La tabla existe o no en la base de datos en Swift

func tableExists(_ tableName:String) -> Bool {
        sqlStatement = "SELECT name FROM sqlite_master WHERE type='table' AND name='\(tableName)'"
        if sqlite3_prepare_v2(database, sqlStatement,-1, &compiledStatement, nil) == SQLITE_OK {
            if sqlite3_step(compiledStatement) == SQLITE_ROW {
                return true
            }
            else {
                return false
            }
        }
        else {
            return false
        }
            sqlite3_finalize(compiledStatement)
    }