Wie überprüfe ich in SQLite, ob eine Tabelle vorhanden ist?

Wie überprüfe ich in SQLite zuverlässig , ob eine bestimmte Benutzertabelle vorhanden ist?

Ich frage nicht nach unzuverlässigen Methoden wie der Überprüfung, ob ein "select *" in der Tabelle einen Fehler zurückgegeben hat oder nicht (ist dies überhaupt eine gute Idee?).

Der Grund ist wie folgt:

In meinem Programm muss ich einige Tabellen erstellen und dann füllen, wenn sie noch nicht vorhanden sind.

Wenn sie bereits vorhanden sind, muss ich einige Tabellen aktualisieren.

Sollte ich stattdessen einen anderen Weg einschlagen, um zu signalisieren, dass die betreffenden Tabellen bereits erstellt wurden - beispielsweise durch Erstellen / Setzen / Setzen eines bestimmten Flags in meiner Programminitialisierungs- / Einstellungsdatei auf der Festplatte oder so?

Oder macht mein Ansatz Sinn?

Ich habe diesen FAQ-Eintrag verpasst.

Zum späteren Nachschlagen lautet die vollständige Abfrage wie folgt:

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

Wo {table_name} ist der Name der zu überprüfenden Tabelle?

Dokumentationsabschnitt als Referenz: Datenbankdateiformat. 2.6. Speicherung des SQL-Datenbankschemas

• Dies gibt eine Liste von Tabellen mit dem angegebenen Namen zurück. Das heißt, der Cursor hat eine Anzahl von 0 (existiert nicht) oder eine Anzahl von 1 (existiert nicht).

Wenn Sie SQLite Version 3.3+ verwenden, können Sie ganz einfach eine Tabelle erstellen mit:

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

Auf die gleiche Weise können Sie eine Tabelle nur entfernen, wenn sie vorhanden ist, indem Sie Folgendes verwenden:

drop table if exists TableName

Eine Variation wäre, SELECT COUNT (*) anstelle von SELECT NAME zu verwenden, d. H.

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

Dies gibt 0 zurück, wenn die Tabelle nicht vorhanden ist, 1, wenn dies der Fall ist. Dies ist wahrscheinlich bei Ihrer Programmierung hilfreich, da ein numerisches Ergebnis schneller / einfacher zu verarbeiten ist. Im Folgenden wird veranschaulicht, wie Sie dies in Android mithilfe von SQLiteDatabase, Cursor, rawQuery mit Parametern tun würden.

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

Du könntest es versuchen:

SELECT name FROM sqlite_master WHERE name='table_name'

Verwenden:

PRAGMA table_info(your_table_name)

Wenn die resultierende Tabelle leer your_table_nameist, existiert sie nicht.

Dokumentation:

PRAGMA schema.table_info (Tabellenname);

Dieses Pragma gibt eine Zeile für jede Spalte in der benannten Tabelle zurück. Zu den Spalten in der Ergebnismenge gehören der Spaltenname, der Datentyp, ob die Spalte NULL sein kann oder nicht, und der Standardwert für die Spalte. Die Spalte "pk" in der Ergebnismenge ist Null für Spalten, die nicht Teil des Primärschlüssels sind, und der Index der Spalte im Primärschlüssel für Spalten, die Teil des Primärschlüssels sind.

Die im Pragma table_info genannte Tabelle kann auch eine Ansicht sein.

Beispielausgabe:

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

Bei SQLite-Tabellennamen wird die Groß- und Kleinschreibung nicht berücksichtigt, beim Vergleich wird jedoch standardmäßig zwischen Groß- und Kleinschreibung unterschieden. Damit dies in allen Fällen ordnungsgemäß funktioniert, müssen Sie hinzufügen COLLATE NOCASE.

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

Wenn der Fehler "Tabelle existiert bereits" angezeigt wird, nehmen Sie die folgenden Änderungen an der SQL-Zeichenfolge vor:

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

Auf diese Weise können Sie die Ausnahmen vermeiden.

Siehe dies :

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

Wenn Sie fmdb verwenden , können Sie einfach FMDatabaseAdditions importieren und die Bool-Funktion verwenden:

[yourfmdbDatabase tableExists:tableName].

Der folgende Code gibt 1 zurück, wenn die Tabelle vorhanden ist, oder 0, wenn die Tabelle nicht vorhanden ist.

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

Beachten Sie, dass zu prüfen , ob eine Tabelle in der TEMP - Datenbank vorhanden ist , müssen Sie verwenden sqlite_temp_masterstatt sqlite_master:

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

Hier ist die Funktion, die ich verwendet habe:

Gegeben ein SQLDatabase-Objekt = db

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

Verwenden Sie diesen Code:

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

Wenn die Anzahl der zurückgegebenen Arrays gleich 1 ist, bedeutet dies, dass die Tabelle vorhanden ist. Sonst existiert es nicht.

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

Hinweis: Dies funktioniert jetzt auf meinem Mac mit Python 3.7.1

Verwenden

SELECT 1 FROM table LIMIT 1;

um zu verhindern, dass alle Datensätze gelesen werden.

Sie können die folgende Abfrage schreiben, um die Tabellenexistenz zu überprüfen.

SELECT name FROM sqlite_master WHERE name='table_name'

Hier ist 'Tabellenname' Ihr Tabellenname, den Sie erstellt haben. Zum Beispiel

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

und prüfe

  SELECT name FROM sqlite_master WHERE name='country'

Der zuverlässigste Weg, den ich derzeit in C # gefunden habe, mit dem neuesten sqlite-net-pcl-Nuget-Paket (1.5.231), das SQLite 3 verwendet, ist folgender:

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

Die Verwendung einer einfachen SELECT-Abfrage ist meiner Meinung nach ziemlich zuverlässig. Vor allem kann es das Vorhandensein von Tabellen in vielen verschiedenen Datenbanktypen (SQLite / MySQL) überprüfen.

SELECT 1 FROM table;

Es ist sinnvoll, wenn Sie einen anderen zuverlässigen Mechanismus verwenden können, um festzustellen, ob die Abfrage erfolgreich war (z. B. wenn Sie eine Datenbank über QSqlQuery in abfragen) Qt ).

Die c ++ - Funktion überprüft die Datenbank und alle angehängten Datenbanken auf das Vorhandensein von Tabellen und (optional) Spalten.

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

Bearbeiten: Kürzlich wurde die Funktion sqlite3_table_column_metadata entdeckt. Daher

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

Dies ist mein Code für 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");
    }
});

Und die andere:

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

Ich dachte, ich würde meine 2 Cent in diese Diskussion stecken, auch wenn es ziemlich alt ist. Diese Abfrage gibt Skalar 1 zurück, wenn die Tabelle existiert, und 0 ansonsten.

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

Tabelle existiert oder nicht in der Datenbank 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)
    }