වගුවක් තිබේද යන්න SQLite හි පරීක්ෂා කරන්නේ කෙසේද?

විශේෂිත පරිශීලක වගුවක් තිබේද යන්න මම විශ්වාසදායක ලෙස SQLite හි පරීක්ෂා කරන්නේ කෙසේද?

මේසය මත ඇති “තෝරන්න *” දෝෂයක් ලබා දුන්නේද නැද්ද යන්න පරීක්ෂා කිරීම වැනි විශ්වාසදායක ක්‍රම මම ඉල්ලන්නේ නැත (මෙය හොඳ අදහසක්ද?).

හේතුව මෙසේ ය:

මගේ වැඩසටහනේ, සමහර වගු දැනටමත් නොපවතී නම් ඒවා නිර්මාණය කර ජනගහනය කළ යුතුය.

ඒවා දැනටමත් තිබේ නම්, මට වගු කිහිපයක් යාවත්කාලීන කළ යුතුය.

සැක සහිත වගු දැනටමත් නිර්මාණය කර ඇති බවට සං signal ා කිරීම වෙනුවට මම වෙනත් මාර්ගයක් ගත යුතුද - නිදසුනක් ලෙස, මගේ වැඩසටහන් ආරම්භක / සැකසුම් ගොනුවේ තැටියේ හෝ වෙනත් යමක් තුළ යම් ධජයක් තැනීමෙන් / තැබීමෙන් / සැකසීමෙන් කියන්න?

නැත්නම් මගේ ප්‍රවේශය අර්ථවත්ද?

මට එම නිති අසන ප්‍රශ්න ඇතුළත් විය.

කෙසේ වෙතත්, අනාගත යොමු කිරීම සඳහා, සම්පූර්ණ විමසුම:

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

{table_name}පරීක්ෂා කිරීමට වගුවේ නම කොහිද?

යොමු කිරීම සඳහා ප්‍රලේඛන අංශය: දත්ත සමුදා ගොනු ආකෘතිය. 2.6. SQL දත්ත සමුදා යෝජනා ක්‍රමය ගබඩා කිරීම

• මෙය නිශ්චිතව දක්වා ඇති නම සහිත වගු ලැයිස්තුවක් ලබා දෙනු ඇත; එනම්, කර්සරයට 0 (නොපවතී) හෝ 1 ගණනය කිරීමක් (පවතී)

ඔබ SQLite අනුවාදය 3.3+ භාවිතා කරන්නේ නම් ඔබට පහසුවෙන් පහත වගුවක් සෑදිය හැකිය:

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

එලෙසම, ඔබට වගුවක් ඉවත් කළ හැක්කේ එය භාවිතා කිරීමෙන් පමණි:

drop table if exists TableName

විචලනය වනුයේ SELECT NAME වෙනුවට SELECT COUNT (*) භාවිතා කිරීමයි

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

මෙය 0 නැවත ලබා දෙනු ඇත, වගුව නොපවතී නම්, 1 එය තිබේ නම්. සංඛ්‍යාත්මක ප්‍රති result ලයක් ඉක්මණින් / සැකසීමට පහසු බැවින් මෙය ඔබේ ක්‍රමලේඛනයේදී ප්‍රයෝජනවත් වේ. පහත දැක්වෙන්නේ ඔබ පරාමිති සහිත SQLiteDatabase, Cursor, rawQuery භාවිතා කරමින් ඇන්ඩ්‍රොයිඩ් තුළ මෙය කරන්නේ කෙසේද යන්නයි.

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

ඔබට උත්සාහ කළ හැකිය:

SELECT name FROM sqlite_master WHERE name='table_name'

භාවිත:

PRAGMA table_info(your_table_name)

එහි ප්‍රති table ලයක් ලෙස ඇති වගුව හිස් නම් your_table_name නොපවතී.

ප්‍රලේඛනය:

PRAGMA schema.table_info (වගුවේ නම);

මෙම ප්‍රාග්මාව නම් කරන ලද වගුවේ එක් එක් තීරුව සඳහා එක් පේළියක් ලබා දෙයි. ප්‍රති result ල කට්ටලයේ තීරුවලට තීරුවේ නම, දත්ත වර්ගය, තීරුව NULL විය හැකිද නැද්ද යන්න සහ තීරුවේ පෙරනිමි අගය ඇතුළත් වේ. ප්‍රති key ල කට්ටලයේ "pk" තීරුව ප්‍රාථමික යතුරේ කොටසක් නොවන තීරු සඳහා ශුන්‍ය වන අතර එය ප්‍රාථමික යතුරේ කොටසක් වන තීරු සඳහා ප්‍රාථමික යතුරේ තීරුවේ දර්ශකය වේ.

Table_info pragma හි නම් කර ඇති වගුව ද දර්ශනයක් විය හැකිය.

උදාහරණ ප්‍රතිදානය:

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

ඔබට "වගුවක් දැනටමත් පවතී" දෝෂයක් ලැබෙන්නේ නම්, පහත පරිදි SQL නූලෙහි වෙනස්කම් කරන්න:

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

මේ ආකාරයෙන් ඔබට ව්‍යතිරේකයන් වළක්වා ගත හැකිය.

මෙය බලන්න :

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

SQLite වගු නම් සිද්ධි සංවේදී නොවේ, නමුත් සංසන්දනය පෙරනිමියෙන් සිද්ධි සංවේදී වේ. සෑම අවස්ථාවකදීම මෙම කාර්යය නිසියාකාරව සිදු කිරීම සඳහා ඔබ එකතු කළ COLLATE NOCASEයුතුය.

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

ඔබ fmdb භාවිතා කරන්නේ නම් , මම හිතන්නේ ඔබට FMDatabaseAdditions ආනයනය කර bool ශ්‍රිතය භාවිතා කළ හැකිය :

[yourfmdbDatabase tableExists:tableName].

පහත කේතය වගුව තිබේ නම් 1 ක් හෝ වගුව නොපවතී නම් 0 ලබා දෙයි.

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

TEMP දත්ත ගබඩාවේ වගුවක් තිබේදැයි පරීක්ෂා කිරීමට, ඔබ sqlite_temp_masterඒ වෙනුවට භාවිතා කළ යුත්තේ sqlite_master:

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

මෙන්න මම භාවිතා කළ ශ්‍රිතය:

SQLDatabase Object = db ලබා දී ඇත

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

මෙම කේතය භාවිතා කරන්න:

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

ආපසු ලබා දුන් අරා ගණන 1 ට සමාන නම් එයින් අදහස් වන්නේ වගුව පවතින බවයි. එසේ නොමැති නම් එය නොපවතී.

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

සටහන: මෙය දැන් මගේ මැක්හි පයිතන් 3.7.1 සමඟ ක්‍රියා කරයි

භාවිත

SELECT 1 FROM table LIMIT 1;

සියලුම වාර්තා කියවීම වැළැක්වීමට.

වගුවේ පැවැත්ම පරීක්ෂා කිරීම සඳහා ඔබට පහත විමසුම ලිවිය හැකිය.

SELECT name FROM sqlite_master WHERE name='table_name'

මෙන්න 'table_name' යනු ඔබ විසින් සාදන ලද ඔබේ වගුවේ නමයි. උදාහරණයක් වශයෙන්

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

පරීක්ෂා කරන්න

  SELECT name FROM sqlite_master WHERE name='country'

SQLite 3 භාවිතා කරන නවතම sqlite-net-pcl nuget පැකේජය (1.5.231) භාවිතා කරමින් C # හි මා දැන් සොයාගෙන ඇති වඩාත්ම විශ්වාසදායක ක්‍රමය පහත පරිදි වේ:

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

සරල තේරීම් විමසුමක් භාවිතා කිරීම - මගේ මතය අනුව - තරමක් විශ්වාසදායකය. බොහෝ විට එයට විවිධ දත්ත සමුදා වර්ගවල (SQLite / MySQL) වගු පැවැත්ම පරීක්ෂා කළ හැකිය.

SELECT 1 FROM table;

විමසුම සාර්ථක වූවාද යන්න තීරණය කිරීම සඳහා ඔබට වෙනත් විශ්වාසදායක යාන්ත්‍රණයක් භාවිතා කළ හැකි විට එය අර්ථවත් කරයි (නිදසුනක් ලෙස, ඔබ Qt හි QSqlQuery හරහා දත්ත සමුදායක් විමසයි ).

c ++ ශ්‍රිතය db සහ වගුවේ සහ (විකල්ප වශයෙන්) තීරුවේ පැවැත්ම සඳහා අමුණා ඇති සියලුම දත්ත සමුදායන් පරීක්ෂා කරයි.

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

සංස්කරණය කරන්න: මෑතකදී sqlite3_table_column_metadata ශ්‍රිතය සොයා ගන්නා ලදි. එබැවින්

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

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

අනෙක:

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

මම හිතුවා මගේ ශත 2 මේ සාකච්ඡාවට දමන්න, එය තරමක් පැරණි එකක් වුවත් .. මෙම විමසුම වගුව තිබේ නම් පරිමාණය 1 සහ වෙනත් ආකාරයකින් 0 ලබා දෙයි.

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

වගුව පවතින්නේ හෝ වේගයෙන් දත්ත සමුදායේ නැත

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