Chciałbym utworzyć bazę danych z wieloma tabelami ze wszystkimi RUD (bez C) w klasie Databasehandler, ale wszystkie tabele utworzone i zaktualizowane w klasie pomocniczej.

Oto, czego używam do pojedynczej tabeli:

package com.cc.folfapptest;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

public class ConfigDatabaseHandler extends SQLiteOpenHelper {

    // All Static variables
    // Database Version
    private static final int DATABASE_VERSION = 1;

    // Database Name
    private static final String DATABASE_NAME = "AndroidSQLLiteDB";

    // Config table name
    private static final String TABLE_CONFIG = "Config";

    // Config Table Columns names
    private static final String KEY_ID = "id"; //
    private static final String KEY_VERSION = "Version";
    private static final String KEY_PRO_KEY = "ProKey";
    private static final String KEY_SERVERID = "ServerID";
    private static final String KEY_SERVERID_ALT = "ServerID_Alt";
    private static final String KEY_CURRENT_BAG_ID = "CurrentBagID";
    private static final String KEY_PLAYER_ID = "PlayerID"; 
    private static final String KEY_PLAYER_SERVER_ID = "PlayerServerID"; 

    String _currentBagID;
    String _playerID;
    String _playerServerID;

    public ConfigDatabaseHandler(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
    }

    // Creating Tables
    @Override
    public void onCreate(SQLiteDatabase db) {
        String CREATE_CONFIG_TABLE = "CREATE TABLE " + TABLE_CONFIG + "("
                + KEY_ID + " INTEGER PRIMARY KEY," 
                + KEY_VERSION + " TEXT," 
                + KEY_PRO_KEY + " TEXT," 
                + KEY_SERVERID + " TEXT," 
                + KEY_SERVERID_ALT + " TEXT," 
                + KEY_CURRENT_BAG_ID + " TEXT," 
                + KEY_PLAYER_ID + " TEXT," 
                + KEY_PLAYER_SERVER_ID + " TEXT" 
                + ")";
        db.execSQL(CREATE_CONFIG_TABLE);
    }

    // Upgrading database
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // Drop older table if existed
        db.execSQL("DROP TABLE IF EXISTS " + TABLE_CONFIG);

        // Create tables again
        onCreate(db);
    }

    /**
     * All CRUD(Create, Read, Update, Delete) Operations
     */

    // Adding new config
    int addConfig(Config config) {
        SQLiteDatabase db = this.getWritableDatabase();

        ContentValues values = new ContentValues();
        values.put(KEY_VERSION, config.getVersion()); // Version
        values.put(KEY_PRO_KEY, config.getProKey()); // ProKey
        values.put(KEY_SERVERID, config.getServerID()); 
        values.put(KEY_SERVERID_ALT, config.getServerID());
        values.put(KEY_CURRENT_BAG_ID, config.getCurrentBagID()); 
        values.put(KEY_PLAYER_ID, config.getPlayerID()); 
        values.put(KEY_PLAYER_SERVER_ID, config.getPlayerServerID());

        // Inserting Row
        long myReturnlong = db.insert(TABLE_CONFIG, null, values);
        int myReturnInt = (int)myReturnlong;
        //db.close(); // Closing database connection
        return myReturnInt;
    }

    // Getting Config
    Config getConfig(int id) {
        SQLiteDatabase db = this.getReadableDatabase();

        Cursor cursor = db.query(TABLE_CONFIG, new String[] { KEY_ID, KEY_VERSION, KEY_PRO_KEY, KEY_SERVERID, KEY_SERVERID_ALT, KEY_CURRENT_BAG_ID, KEY_PLAYER_ID, KEY_PLAYER_SERVER_ID}, KEY_ID + "=?",
                new String[] { String.valueOf(id) }, null, null, null, null);
        if (cursor != null)
            cursor.moveToFirst();

        Config config = new Config();
        config.setID(Integer.parseInt(cursor.getString(0)));
        config.setVersion(cursor.getString(1));
        config.setProKey(cursor.getString(2));
        config.setServerID(cursor.getString(3));
        config.setServerID_Alt(cursor.getString(4));
        config.setCurrentBagID(cursor.getString(5));
        config.setPlayerID(cursor.getString(6));
        config.setPlayerServerID(cursor.getString(7));
        // return player
        return config;
    }

    // Updating Config
    public int updateConfig(Config config) {
        SQLiteDatabase db = this.getWritableDatabase();

        ContentValues values = new ContentValues();
        values.put(KEY_VERSION, config.getVersion()); // Version
        values.put(KEY_PRO_KEY, config.getProKey()); // ProKey
        values.put(KEY_SERVERID, config.getServerID()); // SERVERID
        values.put(KEY_SERVERID_ALT, config.getServerID_Alt()); // SERVERID
        values.put(KEY_CURRENT_BAG_ID, config.getCurrentBagID()); 
        values.put(KEY_PLAYER_ID, config.getPlayerID()); 
        values.put(KEY_PLAYER_SERVER_ID, config.getPlayerServerID());

        // updating row
        return db.update(TABLE_CONFIG, values, KEY_ID + " = ?",
                new String[] { String.valueOf(config.getID()) });
    }

    // Truncate Config Table
    public void truncateConfigTable() {
        SQLiteDatabase db = this.getWritableDatabase();
        db.delete(TABLE_CONFIG, null, null);
    }
}

Patrzyłem na kod w ten sposób i myślę, że jeśli po prostu nie nadpisuję onUreprade () onCreate () w powyższej funkcjonalności klasowej i po prostu obsługuję wszystkie kreacje i zmiany w tabelach jak (nie dokładnie , ale jak):

public class DataBaseHelper extends SQLiteOpenHelper {
public DataBaseHelper(Context context, String name,CursorFactory factory, int version) 
{
           super(context, name, factory, version);
}
// Called when no database exists in disk and the helper class needs
// to create a new one.
@Override
public void onCreate(SQLiteDatabase _db) 
{
        _db.execSQL(DatabaseFunc.DATABASE_CREATE);
        _db.execSQL(DatabaseFunc.DATABASE_CREATE2);

}
// Called when there is a database version mismatch meaning that the version
// of the database on disk needs to be upgraded to the current version.
@Override
public void onUpgrade(SQLiteDatabase _db, int _oldVersion, int _newVersion) 
{
        // Log the version upgrade.
        Log.w("TaskDBAdapter", "Upgrading from version " +_oldVersion + " to " +_newVersion + ", which will destroy all old data");

        // Upgrade the existing database to conform to the new version. Multiple
        // previous versions can be handled by comparing _oldVersion and _newVersion
        // values.
        // The simplest case is to drop the old table and create a new one.
        _db.execSQL("DROP TABLE IF EXISTS " + "LOGIN");
        _db.execSQL("DROP TABLE IF EXISTS " + "SMSREG");
        // Create a new one.
        onCreate(_db);
}

}

z:android-sqllite-multiple-tables czy coś takiego będzie działać? Wolałbym nie łączyć funkcji 8 tabel w jeden plik. Pozwoliłoby mi to także na szybką konwersję i rozpoczęcie korzystania z niego w konfiguracji wielostołowej.

Znalazłem wiele pojedynczych tabel SQL Lite, przykłady pojedynczych tabel są po prostu zasysane, ponieważ gdy w „dzikiej” sytuacji korzystasz z bazy danych dla pojedynczej tabeli? do licha.