Come posso verificare in SQLite se esiste una tabella?

Come posso verificare in modo affidabile in SQLite se esiste una tabella utente specifica?

Non sto chiedendo modi inaffidabili come verificare se un "select *" sulla tabella ha restituito un errore o meno (è anche una buona idea?).

Il motivo è così:

Nel mio programma, devo creare e quindi popolare alcune tabelle se non esistono già.

Se esistono già, devo aggiornare alcune tabelle.

Dovrei invece prendere qualche altro percorso per segnalare che le tabelle in questione sono già state create, ad esempio creando / mettendo / impostando un determinato flag nel mio file di inizializzazione / impostazioni del mio programma sul disco o qualcosa del genere?

O il mio approccio ha senso?

Ho perso quella voce FAQ.

Ad ogni modo, per riferimento futuro, la query completa è:

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

Dov'è {table_name}il nome della tabella da controllare.

Sezione documentazione per riferimento: Formato file database. 2.6. Archiviazione dello schema del database SQL

• Ciò restituirà un elenco di tabelle con il nome specificato; cioè, il cursore avrà un conteggio di 0 (non esiste) o un conteggio di 1 (esiste)

Se si utilizza SQLite versione 3.3+, è possibile creare facilmente una tabella con:

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

Allo stesso modo, è possibile rimuovere una tabella solo se esiste utilizzando:

drop table if exists TableName

Una variante sarebbe quella di utilizzare SELECT COUNT (*) invece di SELECT NAME, ovvero

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

Ciò restituirà 0, se la tabella non esiste, 1 se esiste. Ciò è probabilmente utile nella programmazione poiché un risultato numerico è più rapido / facile da elaborare. Di seguito viene illustrato come eseguire questa operazione in Android utilizzando SQLiteDatabase, Cursor, rawQuery con parametri.

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

Puoi provare:

SELECT name FROM sqlite_master WHERE name='table_name'

Uso:

PRAGMA table_info(your_table_name)

Se la tabella risultante è vuota, allora your_table_namenon esiste.

Documentazione:

PRAGMA schema.table_info (nome-tabella);

Questo pragma restituisce una riga per ogni colonna nella tabella denominata. Le colonne nel set di risultati includono il nome della colonna, il tipo di dati, indipendentemente dal fatto che la colonna possa essere NULL e il valore predefinito per la colonna. La colonna "pk" nel set di risultati è zero per le colonne che non fanno parte della chiave primaria ed è l'indice della colonna nella chiave primaria per le colonne che fanno parte della chiave primaria.

La tabella denominata nel pragma table_info può anche essere una vista.

Esempio di output:

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

I nomi delle tabelle SQLite non fanno distinzione tra maiuscole e minuscole, ma il confronto è case sensitive per impostazione predefinita. Per farlo funzionare correttamente in tutti i casi è necessario aggiungere COLLATE NOCASE.

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

Se viene visualizzato l'errore "tabella già esistente", apportare modifiche nella stringa SQL come di seguito:

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

In questo modo è possibile evitare le eccezioni.

Vedi questo :

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

Se stai usando fmdb , penso che puoi semplicemente importare FMDatabaseAdditions e usare la funzione bool:

[yourfmdbDatabase tableExists:tableName].

Il codice seguente restituisce 1 se la tabella esiste o 0 se la tabella non esiste.

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

Si noti che per verificare se esiste una tabella nel database TEMP, è necessario utilizzare sqlite_temp_masterinvece di sqlite_master:

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

Ecco la funzione che ho usato:

Dato un oggetto SQLDatabase = db

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

Usa questo codice:

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

Se il conteggio degli array restituito è uguale a 1 significa che la tabella esiste. Altrimenti non esiste.

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: ora funziona sul mio Mac con Python 3.7.1

Uso

SELECT 1 FROM table LIMIT 1;

per impedire la lettura di tutti i record.

È possibile scrivere la seguente query per verificare l'esistenza della tabella.

SELECT name FROM sqlite_master WHERE name='table_name'

Qui 'table_name' è il nome della tabella che cosa hai creato. Per esempio

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

e controlla

  SELECT name FROM sqlite_master WHERE name='country'

Il modo più affidabile che ho trovato in C # in questo momento, usando l'ultimo pacchetto nuget sqlite-net-pcl (1.5.231) che utilizza SQLite 3, è il seguente:

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

L'utilizzo di una semplice query SELECT è - a mio avviso - abbastanza affidabile. Soprattutto può controllare l'esistenza della tabella in molti diversi tipi di database (SQLite / MySQL).

SELECT 1 FROM table;

Ha senso quando è possibile utilizzare altri meccanismi affidabili per determinare se la query ha avuto esito positivo (ad esempio, si esegue una query su un database tramite QSqlQuery in Qt ).

La funzione c ++ controlla db e tutti i database collegati per l'esistenza della tabella e (facoltativamente) della colonna.

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

Modifica: recentemente scoperta la funzione sqlite3_table_column_metadata. Quindi

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

Questo è il mio codice per 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");
    }
});

E l'altro:

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

Ho pensato di mettere i miei 2 centesimi in questa discussione, anche se è piuttosto vecchio .. Questa query restituisce lo scalare 1 se la tabella esiste e 0 altrimenti.

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

La tabella esiste o no nel database in 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)
    }