Jak sprawdzić w SQLite, czy tabela istnieje?

Jak niezawodnie sprawdzać w SQLite, czy istnieje konkretna tabela użytkowników?

Nie pytam o niewiarygodne sposoby, takie jak sprawdzenie, czy „select *” na stole zwróciło błąd, czy nie (czy to nawet dobry pomysł?).

Powód jest następujący:

W moim programie muszę utworzyć, a następnie wypełnić niektóre tabele, jeśli jeszcze nie istnieją.

Jeśli już istnieją, muszę zaktualizować niektóre tabele.

Czy zamiast tego powinienem wybrać inną ścieżkę, aby zasygnalizować, że tabele, o których mowa, zostały już utworzone - powiedzmy na przykład, tworząc / umieszczając / ustawiając określoną flagę w pliku inicjalizacji / ustawień mojego programu na dysku lub coś takiego?

Czy moje podejście ma sens?

Brakowało mi tego wpisu FAQ.

W każdym razie, do wglądu w przyszłości, pełne zapytanie to:

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

Gdzie {table_name}jest nazwa tabeli do sprawdzenia.

Dokumentacja w celach informacyjnych: Format pliku bazy danych. 2.6 Przechowywanie schematu bazy danych SQL

• Spowoduje to zwrócenie listy tabel o podanej nazwie; to znaczy kursor będzie miał liczbę 0 (nie istnieje) lub liczbę 1 (istnieje)

Jeśli używasz SQLite w wersji 3.3+, możesz łatwo utworzyć tabelę za pomocą:

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

W ten sam sposób możesz usunąć tabelę, tylko jeśli istnieje, używając:

drop table if exists TableName

Odmianą byłoby użycie SELECT COUNT (*) zamiast SELECT NAME, tj

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

Zwróci 0, jeśli tabela nie istnieje, 1 jeśli tak. Jest to prawdopodobnie przydatne w programowaniu, ponieważ wynik liczbowy jest szybszy / łatwiejszy do przetworzenia. Poniżej pokazano, jak można to zrobić w systemie Android za pomocą SQLiteDatabase, Cursor, rawQuery z parametrami.

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

Możesz spróbować:

SELECT name FROM sqlite_master WHERE name='table_name'

Posługiwać się:

PRAGMA table_info(your_table_name)

Jeśli wynikowa tabela jest pusta, wówczas your_table_namenie istnieje.

Dokumentacja:

PRAGMA schema.table_info (nazwa tabeli);

Ta pragma zwraca jeden wiersz dla każdej kolumny w nazwanej tabeli. Kolumny w zestawie wyników zawierają nazwę kolumny, typ danych, czy kolumna może mieć wartość NULL, oraz wartość domyślną dla kolumny. Kolumna „pk” w zestawie wyników wynosi zero dla kolumn, które nie są częścią klucza podstawowego, i jest indeksem kolumny w kluczu podstawowym dla kolumn, które są częścią klucza podstawowego.

Tabela nazwana w pragma table_info może być również widokiem.

Przykładowe dane wyjściowe:

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

Nazwy tabel SQLite nie rozróżniają wielkości liter, ale w porównaniu domyślnie rozróżniana jest wielkość liter. Aby to działało poprawnie we wszystkich przypadkach, musisz dodać COLLATE NOCASE.

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

Jeśli pojawia się błąd „Tabela już istnieje”, wprowadź zmiany w łańcuchu SQL, jak poniżej:

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

W ten sposób możesz uniknąć wyjątków.

Zobacz to :

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

Jeśli używasz fmdb , myślę, że możesz po prostu zaimportować FMDatabaseAdditions i użyć funkcji bool:

[yourfmdbDatabase tableExists:tableName].

Poniższy kod zwraca 1, jeśli tabela istnieje, lub 0, jeśli tabela nie istnieje.

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

Pamiętaj, że aby sprawdzić, czy tabela istnieje w bazie danych TEMP, musisz użyć sqlite_temp_masterzamiast sqlite_master:

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

Oto funkcja, której użyłem:

Biorąc pod uwagę SQLDatabase Object = db

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

Użyj tego kodu:

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

Jeśli zwrócona liczba tablic jest równa 1, oznacza to, że tabela istnieje. W przeciwnym razie nie istnieje.

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

Uwaga: Działa to teraz na moim komputerze Mac z Python 3.7.1

Posługiwać się

SELECT 1 FROM table LIMIT 1;

aby zapobiec odczytaniu wszystkich rekordów.

Możesz napisać następujące zapytanie, aby sprawdzić istnienie tabeli.

SELECT name FROM sqlite_master WHERE name='table_name'

Tutaj „nazwa_tabeli” to nazwa tabeli, którą utworzyłeś. Na przykład

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

i zaznacz

  SELECT name FROM sqlite_master WHERE name='country'

Najbardziej niezawodny sposób, jaki znalazłem w C #, teraz przy użyciu najnowszego pakietu nuget sqlite-net-pcl (1.5.231), który używa SQLite 3, jest następujący:

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

Korzystanie z prostego zapytania SELECT jest - moim zdaniem - dość niezawodne. Przede wszystkim może sprawdzić istnienie tabeli w wielu różnych typach baz danych (SQLite / MySQL).

SELECT 1 FROM table;

Ma sens, gdy można użyć innego niezawodnego mechanizmu do ustalenia, czy zapytanie zakończyło się powodzeniem (na przykład zapytanie do bazy danych za pośrednictwem QSqlQuery w Qt ).

Funkcja c ++ sprawdza db i wszystkie dołączone bazy danych pod kątem istnienia tabeli i (opcjonalnie) kolumny.

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

Edycja: Niedawno odkryłem funkcję sqlite3_table_column_metadata. W związku z tym

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

Oto mój kod dla 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");
    }
});

I kolejny:

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

Pomyślałem, że postawię moje 2 centy na tę dyskusję, nawet jeśli jest ona raczej stara. To zapytanie zwraca skalar 1, jeśli tabela istnieje, a 0 w przeciwnym razie.

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

Tabela istnieje szybko lub nie w bazie danych

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