Comment puis-je vérifier dans SQLite, si une table existe?

Comment puis-je, de manière fiable, vérifiez dans SQLite, que l'utilisateur table existe?

Je ne demande pas fiable façons, comme vérifier si un "select *" sur le tableau retourné une erreur ou pas (est-ce vraiment une bonne idée?).

La raison en est comme ceci:

Dans mon programme, j'ai besoin de créer, puis de renseigner les quelques tables si elles n'existent pas déjà.

Si elles existent déjà, j'ai besoin de mettre à jour des tables.

Dois-je prendre un autre chemin au lieu de signaler que les tableaux en question ont déjà été créés à - dire, par exemple, par la création d'/mettre/réglage d'un certain drapeau dans mon programme d'initialisation/paramètres du fichier sur le disque ou quelque chose?

Ou est-ce que mon approche de sens?

SQLite va lever une exception si la table dans une de sélectionner n'existe pas. Il n'y a tout simplement pas besoin de plus de fantaisie de travail.
il sera, mais il en sera de n'importe quel nombre d'autres choses. C'est un peu comme voir si cet arbre est vraiment là par la conduite de l'avant avec vos yeux fermés, vous découvrirez une façon ou de l'autre 🙂
bel exemple, mais un peu effrayant, surtout si la voiture de ma voiture...
Je ne sais pas ce qui est le sqlite convention, mais il est plus pythonic demander pardon que demander la permission. c'est à dire d'intercepter l'exception au lieu d'utiliser un conditionnel.
Maintenant, la question n'implique pas de Python, mais en supposant qu'il l'a fait, l'erreur est un générique sqlite3.OperationalError, de sorte que vous avez à analyser le message d'erreur afin de vous assurez qu'il est par exemple "table TABLE_NAME existe déjà" message lorsque vous créez une table, et si non, sur-relancer l'erreur et je pense que il n'ya aucune garantie que le libellé de l'erreur ne change pas.

InformationsquelleAutor PoorLuzer | 2009-10-21

sqlite

957

J'ai manqué cette entrée de la FAQ.

De toute façon, pour référence future, la requête complète est:
```
SELECT name FROM sqlite_master WHERE type='table' AND name='{table_name}';
```
Où {table_name} est le nom de la table à vérifier.

Section Documentation de référence: La Base De Données De Format De Fichier. 2.6. De stockage De La Base de données SQL Schéma
- Ce sera le retour de la liste des tables avec le nom spécifié, qui est, le curseur aura un nombre de 0 (n'existe pas) ou un nombre de 1 (n'existe pas)
- Qui de l'SQLite documentation couvre ces tables système?
- Veselov: La section intitulée "Format de Fichier Pour les Bases de données SQLite": sqlite.org/fileformat2.html
- Cela ne fonctionne pas si vous utilisez Adobe Air SQLite, voici une (meilleure) solution de rechange pour le cas que vous êtes la programmation en AS3/Air: stackoverflow.com/questions/4601707/...
- Cela ne fonctionne pas pour les tables temporaires, cependant. Les tables temporaires sont dans "sqlite_temp_master."
- comment écrire la même requête pour le web-sql
- Je suis à l'aide de zend framework 2 avec sqlite, lorsqu'il est utilisé de cette requête, zf2 ne m'autorise pas à aller plus loin, c'est à dire 'sqlite_master' ne me donne pas le résultat attendu. J'ai donc utilisé le dessous de solution, mais fonctionne sans problème 🙂
- Est-ce à retourner un booléen? En quoi est-il de retour si la table n'a ou n'existe pas?
- Cela renvoie à une liste de tables avec le nom spécifié, qui est, le curseur aura un nombre de 0 (n'existe pas) ou un nombre de 1 (n'existe pas).
- pouvez vous s'il vous plaît mettre à jour votre réponse comment faire pour vérifier le résultat de la requête pour décider de la table existe ou pas? Il vous permettra d'économiser le temps de newbie
- J'exécute cette requête et de vérifier si(retour > 0) mais de retour renvoie toujours -1 lorsque j'exécute l'instruction. Ce serait donner un -1?
- Cela dépend vraiment de ce langage que vous utilisez ces requêtes SQL à l'intérieur. Par exemple, un Android Cursor's méthode de getCount() ne devriez jamais vraiment de retour -1 (plus probablement une exception sera levée sur ou avant que si quelque chose était faux).
- J'ai édité la réponse ci-dessus pour inclure l'exemple que vous avez demandé. J'espère que c'est assez clair.
InformationsquelleAutor PoorLuzer
531

Si vous utilisez SQLite version 3.3+ vous permet de créer facilement un tableau avec:
```
create table if not exists TableName (col1 typ1, ..., colN typN)
```
De la même façon, vous pouvez supprimer une table seulement si il existe à l'aide de:
```
drop table if exists TableName
```
- Notez que le create table déclaration est incomplète (il manque les colonnes de la table de spécification).
- il est également similaire pour construire des index: créer un index si n'existe pas TableName_col1 sur le nom de la table(col1)
- Cela ne devrait pas être accepté de répondre, mais si la question est formulé différemment. L'OP n'a pas demandé comment vérifier une table avant de les abandonner ou de les créer. Que faire si vous devez effectuer une requête sur une table qui peut-être n'existe pas? C'est le problème que je me pose maintenant, et l'on a accepté la réponse qui fonctionne le mieux dans cette général énoncé du problème. C'est une bonne alternative rapide.
InformationsquelleAutor arthur johnston
167

Une variante serait d'utiliser SELECT COUNT(*) au lieu de SÉLECTIONNER un NOM, c'est à dire
```
SELECT count(*) FROM sqlite_master WHERE type='table' AND name='table_name';
```
Ce sera le retour de 0, si la table n'existe pas, 1 si elle l'est. Cela est probablement utile dans votre programmation, car un résultat numérique est plus rapide /plus facile à traiter. L'exemple suivant illustre la façon dont vous voulez faire cela dans Android à l'aide de SQLiteDatabase, Curseur, rawQuery avec des paramètres.
```
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;
}
```
- Je crois un "1" serait même plus rapide.
- Pourquoi est-curseur.getInt(0) est égal au nombre d'enregistrements dans la base de données?
- Nous comptons le nombre de fois que la TABLE s'affiche dans sqlite schéma. Une valeur 0 signifie que la table n'existe pas. Un nombre de 1 signifie que la table n'existe pas. Ce sont les deux seules valeurs attendues du comte.
- Alors que le nombre (de COUNT(*)) est facile à traiter, il est encore plus facile de revenir à l'existence d'une ligne ou non, et s'il y a une rangée de là, alors il existe, si il n'y a pas de ligne ça ne marche pas. (Vous avez déjà vérification de l'échec dans la moveToFirst, de sorte que le travail pourrait être fait à ce point.)
- Veuillez mettre à jour votre code pour fermer le curseur avant de vous renvoyer false.
- Sur la deuxième pensée peuvent que renvoyer false jamais arriver? Semble très peu probable.
InformationsquelleAutor Stephen Quan
41

Vous pourriez essayer:
```
SELECT name FROM sqlite_master WHERE name='table_name'
```
- type = tableau serait utile tho
- Si à l'aide de C#, de ne pas utiliser cette commande dans un SQLiteReader reader = cmd.ExecuteReader(); et faire un dt.Load(reader) (où dt est un DataTable). J'ai trouvé qu'il donne ce Object reference is not an instance of an object exception sur le .Load() si la table n'est pas trouvé. Au lieu de cela, utilisez un SQLiteDataAdapter adapter = new SQLiteDataAdapter(cmd); et ne adapter.Fill(ds), où ds est un DataSet. Vous pouvez ensuite voir si ds.Tables.Count > 0 et return ds.Tables[0]; si oui (ou else return null). Ensuite, vous pouvez vérifier que DataTable pour être null, si dt.Rows != null, et si dt.Rows.Count>0
InformationsquelleAutor Galwegian
33

Si vous obtenez une "table existe déjà erreur", de faire des changements dans la chaîne SQL comme ci-dessous:
```
CREATE table IF NOT EXISTS table_name (para1,para2);
```
De cette façon, vous pouvez éviter les exceptions.

InformationsquelleAutor Rakesh Chaudhari
32

SQLite noms de table sont insensibles à la casse, mais la comparaison est sensible à la casse par défaut. Pour faire ce travail correctement dans tous les cas, vous devez ajouter COLLATE NOCASE.
```
SELECT name FROM sqlite_master WHERE type='table' AND name='table_name' COLLATE NOCASE
```
InformationsquelleAutor Brice M. Dempsey
32

Utilisation:
```
PRAGMA table_info(your_table_name)
```
Si le tableau est vide, c'est your_table_name n'existe pas.

Documentation:

PRAGMA schéma.table_info(table-name);

Ce pragma retourne une ligne pour chaque colonne dans la table désignée. Colonnes du jeu de résultats inclure le nom de la colonne, le type de données, si la colonne peut être NULL, et la valeur par défaut de la colonne. Le "pk" colonne dans le jeu de résultats est de zéro pour les colonnes qui ne font pas partie de la clé primaire, et est l'index de la colonne de la clé primaire pour les colonnes qui font partie de la clé primaire.

La table nommée dans la table_info pragma peut aussi être vue.

Exemple de sortie:
```
cid|name|type|notnull|dflt_value|pk
0|id|INTEGER|0||1
1|json|JSON|0||0
2|name|TEXT|0||0
```
- C'est un excellent moyen pour déterminer si une table existe en Python.
- ou Xamarin Forms
- C'est un excellent moyen pour obtenir les définitions de colonne par programmation
InformationsquelleAutor Diego Vélez

Voir cette:

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

InformationsquelleAutor Anton Gogolev

22

Si vous utilisez fmdb, je pense que vous pouvez juste importation FMDatabaseAdditions et l'utilisation de la fonction bool:
```
[yourfmdbDatabase tableExists:tableName].
```
- Assurez-vous d'importer "FMDatabaseAdditions.h" afin d'utiliser cette méthode, sinon vous allez me demande pourquoi ils l'ont enlevé! 🙂
- Bien que cela pourrait être une bonne réponse, la question était de savoir sqlite pas une bibliothèque en particulier dans une langue particulière. Je pense que la réponse devrait être de fournir des code sql, pas un appel à l'une des méthodes de la bibliothèque
InformationsquelleAutor user655489
13

Le code suivant renvoie 1 si la table existe, ou 0 si la table n'existe pas.
```
SELECT CASE WHEN tbl_name = "name" THEN 1 ELSE 0 END FROM sqlite_master WHERE tbl_name = "name" AND type = "table"
```
- Ce sera toujours renvoyer rien si la table n'existe pas, parce que la condition empêche aucun résultat.
InformationsquelleAutor pacheco
10

Noter que pour vérifier si une table existe dans le TEMP de base de données, vous devez utiliser sqlite_temp_master au lieu de sqlite_master:
```
SELECT name FROM sqlite_temp_master WHERE type='table' AND name='table_name';
```
InformationsquelleAutor Scott Deerwester
9

Voici la fonction que j'ai utilisé:

Donné un SQLDatabase Objet = db
```
public boolean exists(String table) {
    try {
         db.query("SELECT * FROM " + table);
         return true;
    } catch (SQLException e) {
         return false;
    }
}
```
- J'ai malheureusement eu à l'utiliser dans mon application Android que j'ai trouvé que les appareils Samsung n'utilisez pas la norme sqlite_master structure de la table que tout le monde travaille.
InformationsquelleAutor DroidGrailer
7

Utiliser ce code:
```
SELECT name FROM sqlite_master WHERE type='table' AND name='yourTableName';
```
Si le tableau renvoyé compte est égal à 1, cela signifie que la table existe. Sinon, il n'existe pas.

InformationsquelleAutor asmad
3

Utilisation
```
SELECT 1 FROM table LIMIT 1;
```
à prévenir tous les enregistrements de la lecture.
- Cette méthode retourne NULL si la table existe, mais ne dispose pas de tous les enregistrements.
- Si la table n'existe pas, il renvoie une erreur. Attraper, et vous savez qu'elle n'existe pas.
- à l'aide d'erreur de manipulation que le contrôle de flux est généralement pas considéré comme une bonne pratique. Cela devrait probablement être évitée.
InformationsquelleAutor Franz Fahrenkrog Petermann
3

Le moyen le plus fiable que j'ai trouvé dans C#, au droit maintenant, à l'aide de la dernière sqlite-net-pcl package nuget (1.5.231) qui utilise SQLite 3, est comme suit:
```
var result = database.GetTableInfo(tableName);
if ((result == null) || (result.Count == 0))
{
    database.CreateTable<T>(CreateFlags.AllImplicit);
}
```
InformationsquelleAutor Matthew Joughin

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

Remarque: Ce travail est maintenant sur mon Mac avec Python 3.7.1

Cela ressemble plus propre que tous les autres réponses.. Merci!!!!!
Ne marche pas pour moi: avoir à effacer le {} crochets autour de table_name, alors son amende.
Assurez-vous que table_name n'est pas fourni de untrused source (comme la saisie de l'utilisateur), sinon il sera vulnérable à une injection SQL. Il est toujours préférable d'utiliser des paramètres au lieu de texte des techniques de manipulation

InformationsquelleAutor Douglas Goodall

2

À l'aide d'une simple requête SELECT est - à mon avis - tout à fait fiable. La plupart de tout ce qu'il peut consulter le tableau existence dans beaucoup de différents types de base de données (SQLite /MySQL).
```
SELECT 1 FROM table;
```
Il de sens que si vous pouvez utiliser d'autres mécanismes fiables pour déterminer si la requête a réussi (par exemple, interroger une base de données via QSqlQuery dans Qt).

InformationsquelleAutor Grz
2

Vous pouvez écrire la requête suivante pour vérifier la table existence.
```
SELECT name FROM sqlite_master WHERE name='table_name'
```
Ici "table_name" est le nom de votre table que vous avez créé. Par exemple
```
 CREATE TABLE IF NOT EXISTS country(country_id INTEGER PRIMARY KEY AUTOINCREMENT, country_code TEXT, country_name TEXT)"
```
et vérifier
```
  SELECT name FROM sqlite_master WHERE name='country'
```
- Comment est-ce différent de la déjà accepté topvoted réponse à partir de 9 ans?
InformationsquelleAutor AN.Anannthakrrishnan

c++ fonction vérifie la db et toutes les bases de données attachées d'existence de table et (éventuellement) de la colonne.

bool exists(sqlite3 *db, string tbl, string col="*")
{
    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;
}

InformationsquelleAutor NoComprende

C'est mon code pour 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");
    }
});

Et l'autre:

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

InformationsquelleAutor Zappescu

Je pensais mettre mes 2 cents à cette discussion, même si c'est plutôt ancienne..
Cette requête renvoie scalaire 1 si la table existe et 0 sinon.

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

InformationsquelleAutor Piotr Rodak

Table existe ou non dans la base de données de 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)
    }

InformationsquelleAutor CSE 1994

Vous devez vous connecter pour publier un commentaire.