Datenbank kopiert, aber Tabelle ist leer

Question

Ich habe eine Tabelle in meiner App vorinstalliert. Die Tabelle enthält ID, Name und Bild vom Typ Blob. Ich folgte this Artikel, um die Datenbank vorzuladen. Die Datenbank wurde ordnungsgemäß kopiert (wie im Protokoll), aber ich kann nicht auf den Tabellennamen zugreifen. Ich habe versucht, den Namen zu drucken, um sicher zu sein, aber die Tabelle ist zugänglich. Hier sind meine Code:

MainActivity.java:

package com.arafatpiyada.preloadeddatabsedemo; 
import android.database.Cursor; 
import android.database.sqlite.SQLiteDatabase; 
import android.support.v7.app.AppCompatActivity; 
import android.os.Bundle; 
import android.util.Log; 

public class MainActivity extends AppCompatActivity { 

    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_main); 

     Repository repo = Repository.getInstance(this); 

     repo.close(); 
     SQLiteDatabase db = repo.getWritableDatabase(); 

     if (db != null){ 

      Log.i("Database", db.getPath()); 
      Log.i("Database Details: ", Integer.toString(db.getVersion())); 
     } 


     Cursor c = db.rawQuery("SELECT name FROM sqlite_master WHERE type='table'", null); 

     if (c.moveToFirst()) { 
      while (!c.isAfterLast()) { 

       Log.i("Table Content: ", c.getString(0)); 
       c.moveToNext(); 
      } 
     } 

    } 


} 

Repository.java

package com.arafatpiyada.preloadeddatabsedemo; 
import android.content.Context; 
import android.content.res.AssetManager; 
import android.database.sqlite.SQLiteDatabase; 
import android.database.sqlite.SQLiteException; 
import android.database.sqlite.SQLiteOpenHelper; 

import java.io.File; 
import java.io.FileOutputStream; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.OutputStream; 

public class Repository extends SQLiteOpenHelper { 

private static final int VERSION = 1; 
    private static final String DATABASE_NAME = "fruits.db"; 
    private static File DATABASE_FILE; 

    // This is an indicator if we need to copy the 
    // database file. 
    private boolean mInvalidDatabaseFile = false; 
    private boolean mIsUpgraded = false; 
    private Context mContext; 

    /** 
    * number of users of the database connection. 
    * */ 
    private int mOpenConnections = 0; 

    private static Repository mInstance; 

    synchronized static public Repository getInstance(Context context) { 
     if (mInstance == null) { 
      mInstance = new Repository(context.getApplicationContext()); 
     } 
     return mInstance; 
    } 

    private Repository(Context context) { 
     super(context, DATABASE_NAME, null, VERSION); 
     this.mContext = context; 

     SQLiteDatabase db = null; 
     try { 
      db = getReadableDatabase(); 
      if (db != null) { 
       db.close(); 
      } 

      DATABASE_FILE = context.getDatabasePath(DATABASE_NAME); 

      if (mInvalidDatabaseFile) { 
       copyDatabase(); 
      } 
      if (mIsUpgraded) { 
       doUpgrade(); 
      } 
     } catch (SQLiteException e) { 
     } finally { 
      if (db != null && db.isOpen()) { 
       db.close(); 
      } 
     } 
    } 

    @Override 
    public void onCreate(SQLiteDatabase db) { 
     mInvalidDatabaseFile = true; 
    } 

    @Override 
    public void onUpgrade(SQLiteDatabase database, 
          int old_version, int new_version) { 
     mInvalidDatabaseFile = true; 
     mIsUpgraded = true; 
    } 

    /** 
    * called if a database upgrade is needed 
    */ 
    private void doUpgrade() { 
     // implement the database upgrade here. 
    } 

    @Override 
    public synchronized void onOpen(SQLiteDatabase db) { 
     super.onOpen(db); 
     // increment the number of users of the database connection. 
     mOpenConnections++; 
     if (!db.isReadOnly()) { 
      // Enable foreign key constraints 
      db.execSQL("PRAGMA foreign_keys=ON;"); 
     } 
    } 

    /** 
    * implementation to avoid closing the database connection while it is in 
    * use by others. 
    */ 
    @Override 
    public synchronized void close() { 
     mOpenConnections--; 
     if (mOpenConnections == 0) { 
      super.close(); 
     } 
    } 

    private void copyDatabase() { 
     AssetManager assetManager = mContext.getResources().getAssets(); 
     InputStream in = null; 
     OutputStream out = null; 
     try { 
      in = assetManager.open(DATABASE_NAME); 
      out = new FileOutputStream(DATABASE_FILE); 
      byte[] buffer = new byte[1024]; 
      int read = 0; 
      while ((read = in.read(buffer)) != -1) { 
       out.write(buffer, 0, read); 
      } 
     } catch (IOException e) { 
     } finally { 
      if (in != null) { 
       try { 
        in.close(); 
       } catch (IOException e) {} 
      } 
      if (out != null) { 
       try { 
        out.close(); 
       } catch (IOException e) {} 
      } 
     } 
     setDatabaseVersion(); 
     mInvalidDatabaseFile = false; 
    } 

    private void setDatabaseVersion() { 
     SQLiteDatabase db = null; 
     try { 
      db = SQLiteDatabase.openDatabase(DATABASE_FILE.getAbsolutePath(), null, 
        SQLiteDatabase.OPEN_READWRITE); 
      db.execSQL("PRAGMA user_version = " + VERSION); 
     } catch (SQLiteException e) { 
     } finally { 
      if (db != null && db.isOpen()) { 
       db.close(); 
      } 
     } 
    } 


} 

Answer 1

Ich schlage vor, Sie Android SQLiteAssetHelper zu verwenden. Es ist robuster als der Code, den Sie verwendet haben.

Für Tabellennamen anstelle Kriterien:

SELECT name FROM sqlite_master WHERE type='table' 

Verwenden Sie diese Abfrage:

SELECT name FROM sqlite_master WHERE type like 'table' 

Wenn ich mich richtig erinnere, fand ich oft, dass die Abfrage mit '=' Auswahl nicht funktionieren , aber arbeiten Sie immer mit wie.