Como verifico no SQLite se existe uma tabela?

Como, de forma confiável , verifico no SQLite se existe uma tabela de usuário específica?

Não estou pedindo formas não confiáveis, como verificar se um "select *" na tabela retornou um erro ou não (isso é uma boa idéia?).

O motivo é o seguinte:

No meu programa, preciso criar e preencher algumas tabelas se elas ainda não existirem.

Se eles já existirem, preciso atualizar algumas tabelas.

Em vez disso, devo seguir outro caminho para sinalizar que as tabelas em questão já foram criadas - por exemplo, criando / colocando / definindo um determinado sinalizador no meu arquivo de inicialização / configurações do programa no disco ou algo assim?

Ou minha abordagem faz sentido?

Perdi a entrada da FAQ.

De qualquer forma, para referência futura, a consulta completa é:

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

Onde {table_name}é o nome da tabela para verificar.

Seção de documentação para referência: Formato de arquivo do banco de dados. 2.6 Armazenamento do esquema do banco de dados SQL

• Isso retornará uma lista de tabelas com o nome especificado; isto é, o cursor terá uma contagem de 0 (não existe) ou uma contagem de 1 (existe)

Se você estiver usando o SQLite versão 3.3 ou superior, poderá criar facilmente uma tabela com:

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

Da mesma maneira, você pode remover uma tabela apenas se ela existir, usando:

drop table if exists TableName

Uma variação seria usar SELECT COUNT (*) em vez de SELECT NAME, ou seja,

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

Isso retornará 0, se a tabela não existir, 1 se existir. Isso provavelmente é útil em sua programação, pois um resultado numérico é mais rápido / fácil de processar. A seguir, ilustra como você faria isso no Android usando SQLiteDatabase, Cursor, rawQuery com 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;
}

Você poderia tentar:

SELECT name FROM sqlite_master WHERE name='table_name'

Usar:

PRAGMA table_info(your_table_name)

Se a tabela resultante estiver vazia, your_table_nameela não existe.

Documentação:

Schema.table_info PRAGMA (nome da tabela);

Esse pragma retorna uma linha para cada coluna na tabela nomeada. As colunas no conjunto de resultados incluem o nome da coluna, o tipo de dados, se a coluna pode ou não ser NULL e o valor padrão para a coluna. A coluna "pk" no conjunto de resultados é zero para colunas que não fazem parte da chave primária e é o índice da coluna na chave primária para colunas que fazem parte da chave primária.

A tabela nomeada no pragma table_info também pode ser uma visualização.

Exemplo de saída:

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

Os nomes de tabela SQLite não diferenciam maiúsculas de minúsculas, mas a comparação diferencia maiúsculas de minúsculas por padrão. Para fazer isso funcionar corretamente em todos os casos, você precisa adicionar COLLATE NOCASE.

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

Se você estiver recebendo um erro "a tabela já existe", faça as alterações na string SQL, conforme abaixo:

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

Dessa forma, você pode evitar as exceções.

Veja isto :

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

Se você estiver usando o fmdb , acho que você pode importar o FMDatabaseAdditions e usar a função bool:

[yourfmdbDatabase tableExists:tableName].

O código a seguir retorna 1 se a tabela existir ou 0 se a tabela não existir.

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

Observe que, para verificar se existe uma tabela no banco de dados TEMP, você deve usar em sqlite_temp_mastervez de sqlite_master:

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

Aqui está a função que eu usei:

Dado um objeto SQLDatabase = db

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

Use este código:

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

Se a contagem de matriz retornada for igual a 1, significa que a tabela existe. Caso contrário, não 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: Isso está funcionando agora no meu Mac com o Python 3.7.1

Usar

SELECT 1 FROM table LIMIT 1;

para impedir que todos os registros sejam lidos.

Você pode escrever a seguinte consulta para verificar a existência da tabela.

SELECT name FROM sqlite_master WHERE name='table_name'

Aqui 'table_name' é o nome da sua tabela que você criou. Por exemplo

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

e verifique

  SELECT name FROM sqlite_master WHERE name='country'

A maneira mais confiável que encontrei no C # agora, usando o pacote mais recente do sqlite-net-pcl nuget (1.5.231) que usa o SQLite 3, é o seguinte:

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

Usar uma consulta SELECT simples é - na minha opinião - bastante confiável. Acima de tudo, ele pode verificar a existência da tabela em muitos tipos diferentes de banco de dados (SQLite / MySQL).

SELECT 1 FROM table;

Faz sentido quando você pode usar outro mecanismo confiável para determinar se a consulta foi bem-sucedida (por exemplo, você consulta um banco de dados via QSqlQuery no Qt ).

A função c ++ verifica o banco de dados e todos os bancos de dados anexados quanto à existência de tabela e (opcionalmente) coluna.

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

Edit: Descoberto recentemente a função sqlite3_table_column_metadata. Conseqüentemente

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 é o meu 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");
    }
});

E o outro:

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

Eu pensei em colocar meus 2 centavos nessa discussão, mesmo que seja um pouco antigo. Essa consulta retorna o escalar 1 se a tabela existir e 0 caso contrário.

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

A tabela existe ou não no banco de dados no 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)
    }