Create Table che falliscono

Ciao,

Mi falliscono tutte le CREATE TABLE e di conseguenza le INSERT con errore ‘no such a table’.
Come mai? Sbaglio la creazione del database?
Aiuto.


My class example:
public class MainActivity extends Activity {

DatabaseHelper databaseHelper = new DatabaseHelper(this);

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

setContentView(R.layout.main);

String queryTest="create table TEST_TABLE(ID integer,T_MESSAGE text)";
databaseHelper.executeQuery(queryTest);
queryTest="INSERT INTO TEST_TABLE (ID,T_MESSAGE) VALUES (1,'1');";
databaseHelper.executeQuery(queryTest);

}





My database:

public class DatabaseHelper extends SQLiteOpenHelper {

private static String DATABASE_NAME = "pro.db";
private static String DATABASE_PATH = "/data/data/it.sysman.mobile.contactpro/databases/";



private static final int SCHEMA_VERSION = 2;

public DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, SCHEMA_VERSION);
}

@Override
public void onCreate(SQLiteDatabase sqlDB) {
try {



} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}


@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// TODO Auto-generated method stub

}
private SQLiteDatabase openDataBase(int flag) {

SQLiteDatabase checkDB = null;

try {

Environment.getExternalStorageDirectory();
Environment.getDataDirectory();
Environment.getRootDirectory();
Environment.getExternalStorageState();
checkDB = getWritableDatabase();

} catch (Exception e) {
e.printStackTrace();
}

return checkDB;
}


public String executeQuery(String query) {

SQLiteDatabase sqlDB = null;
Cursor data = null;
try {
sqlDB = openDataBase(SQLiteDatabase.NO_LOCALIZED_COLLATORS );
data = sqlDB.rawQuery(query, null);

if (data.getCount() == 0)
return null;

} catch (Exception e) {
e.printStackTrace();
} finally {
if (data != null)
data.close();
if (sqlDB != null)
sqlDB.close();
}
return null;
}
}

Ho rifatto la classe, migliorandola, è ho risolto. Chiudo

Ciao,

appena hai 1 momento e se vorrai, vorresti postare la soluzione? :)

Grazie,
Ciao

a occhio direi che il problema era che non aveva implementato l'onCreate() di DatabaseHelper.

Scusate l'attesa, ma sono un pò confuso con questo db.

il problema l'ho risolto modificando la stringa 'sqlDB.rawQuery(query, null)' in 'sqlDB.execQuery(query)' .
Probabilmente è più adatto per le select rawQuery.
Ora funziona eppure non mi convince qualcosa. E' troppo lento ad eseguire una serie di query.
Allora ho modificato il codice aprendo solo una volta la connessione ed eseguendo in un ciclo for le query.
Ma su un 400 istruzioni ci mette 2min e30 circa.
Secondo me è tanto.
Secondo voi sbaglio qualcosa o si potrebbe optare per altre strade?
é giusto far eseguire le istruzioni a SQLiteDatabase sqlDB?

Di seguito il mio codice modificato.

codice:

---

miaClasse:

        public void eseguiTanteQuery(){
       
                DatabaseHelper db=new DatabaseHelper(this);
                String query;
                sqlDb=db.openDB();
               
                for (int i=0; i<queryLista.length; i++){
                        query=queryLista[i];
                        sqlDB.rawQuery();
                }
       
                sqlDB.close();       
        }

classe DatabaseHelper:

 public SQLiteDatabase openDb(){

  SQLiteDatabase sqlDB = null;
  sqlDB = openDataBase(SQLiteDatabase.NO_LOCALIZED_COLLATORS );
  return sqlDB;
 }

---

Tu frank17next che ne pensi?
Help...o_O

posso vedere l'intero DatabaseHelper? se l'onCreate() non l'hai implementato e crei il db con la tua openDB(), praticamente non stai usando SQLiteOpenHelper, non ha senso che lo estendi, e soprattutto ne perdi le funzionalita'.

circa la lentezza, le raw query sono lente perche' ognuna viene valutata singolarmente. un sistema per velocizzare è eseguirle entro una transazione (per cui prepari una richiesta multipla che viene eseguita in una volta, eliminando parecchio overhead), e un altro da usare insieme e' quello degli gli statement precompilati. con questi due sistemi puo' diventare anche 10 volte piu' veloce, ma ovviamente dipende da che query fai. sono tutte diverse? se sono tutte simili, probabilmente puoi ridurle a un'unica select.

EDIT: ops ho letto male, credevo fossero select. se sono insert, transazioni e statement sono la via giusta.

Prima di tutto grazie.
Ok allora cerchiamo di far chiarezza sul mio DatabaseHelper.

CLASSE DATABASEHELPER:

codice:

---



public class DatabaseHelper extends SQLiteOpenHelper {
       
        private static final int SCHEMA_VERSION = 2;


        private static final int VERSION = 1;
        private static File DATABASE_FILE;

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

        public DatabaseHelper(Context context, String DATABASE_NAME) {
                super(context, DATABASE_NAME, null, SCHEMA_VERSION);
                this.mContext = context;
                    // This will set the DATABASE_FILE to the path used by
                    // SQLiteOpenHelper when it creates database files.
                DATABASE_FILE = context.getDatabasePath(DATABASE_NAME);
               
               
                SQLiteDatabase db = null;
                try {
                  db = getReadableDatabase();
                  if (db != null) {
                    db.close();
                  }
                  if (mInvalidDatabaseFile) {
                    copyDatabase(DATABASE_NAME);
                  }
                } 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;
        }
       

        private SQLiteDatabase openDataBase(int flag) {

                SQLiteDatabase checkDB = null;

                try {

                        checkDB = getWritableDatabase();
                        checkDB.getPath();

                } catch (Exception e) {
                        e.printStackTrace();
                }

                return checkDB;
        }
       
       
       
        public SQLiteDatabase openDb() {

                SQLiteDatabase sqlDB = null;
                sqlDB = openDataBase(SQLiteDatabase.NO_LOCALIZED_COLLATORS);
       
               
                return sqlDB;

        }
       
        public void closeDb(SQLiteDatabase sqlDB) {

                sqlDB.close();               
        }
       
        public void copyDatabase(String DATABASE_NAME) {

                AssetManager assetManager = mContext.getResources().getAssets();
                  InputStream in = null;
                  OutputStream out = null;
                  try {
                    in = assetManager.open("Database/"+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) {
                          e.getStackTrace();
                  } 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();
                    }
                  }
        }
       
        public int getIdTimeCombo(String ora) {
                SQLiteDatabase sqlDB = null;
                Cursor data = null;
                try {
                        sqlDB = openDataBase(SQLiteDatabase.NO_LOCALIZED_COLLATORS);
                        int id=0;

                        data = sqlDB.rawQuery("SELECT ID FROM TIME_COMBO WHERE ID >= (SELECT ID FROM TIME_COMBO WHERE TIME LIKE                '"+ora+".00%') limit 1" , null);
                       
                        if (data.getCount() == 0)
                                return 0;

                        while (data.moveToNext()) {
                                id=data.getInt(0);
                        }
                        return (id);
                } catch (SQLiteException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                } finally {
                        if (data != null)
                                data.close();
                        if (sqlDB != null)
                                sqlDB.close();
                }
                return 0;
        }
       


       
        // esegui query
        public String execQuery(String query,SQLiteDatabase sqlDB) {

                try {
                        sqlDB.execSQL(query);

                } catch (Exception e) {
                        e.printStackTrace();
                } finally {

                }
                return null;
        }

       
}

---

CLASSE MIA:

codice:

---

public class SynchronizedActivity extends Activity{


        DatabaseHelper databaseHelper;
        String DATABASE_NAME="db.db";



        private boolean sincronizzazioneInCorso=false;
       
        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.syncro);

                databaseHelper = new DatabaseHelper(this,DATABASE_NAME);
                eseguitanteQuery();

        }

        private void eseguitanteQuery(){


                SQLiteDatabase sqlDB=databaseHelper.openDb();
                arrayQueryInsert=......;


                for(int i=0; i< arrayQueryInsert.length; i++) {

                        String query =arrayQueryInsert[i];       
                        databaseHelper.execQuery(query, sqlDB);

                }

                databaseSyncro.closeDb(sqlDB);
        }

}

---

Allora...

quando faccio 'databaseHelper = new DatabaseHelper(this,DATABASE_NAME);' entro nell'onCreate giusto?
Quindi utilizzo correttamente il DatabaseHelper o sbaglio qualcosa?

Poi per qualsiasi select utilizzo metodi tipo 'databaseHelper.getIdTimeCombo(parametro)',
mentre per far insert,update, delete utilizzo 'databaseHelper.execQuery(query, sqlDB)'.

Ho sempre fatto così ma mi piacerebbe imparare ad utilizzare gli statement e le transazioni.
Mi puoi aiutare facendo un esempio modificando il mio codice per le insert utilizzando statement e transazione?

Anche per le select mi puoi far un esempio come migliorare la velocità?
Grazie mille

Quote:

---

Originariamente inviato da Rookye

Prima di tutto grazie.
Ok allora cerchiamo di far chiarezza sul mio DatabaseHelper.

CLASSE DATABASEHELPER:

codice:

---



public class DatabaseHelper extends SQLiteOpenHelper {
       
        private static final int SCHEMA_VERSION = 2;


        private static final int VERSION = 1;
        private static File DATABASE_FILE;

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

        public DatabaseHelper(Context context, String DATABASE_NAME) {
                super(context, DATABASE_NAME, null, SCHEMA_VERSION);
                this.mContext = context;
                    // This will set the DATABASE_FILE to the path used by
                    // SQLiteOpenHelper when it creates database files.
                DATABASE_FILE = context.getDatabasePath(DATABASE_NAME);
               
               
                SQLiteDatabase db = null;
                try {
                  db = getReadableDatabase();
                  if (db != null) {
                    db.close();
                  }
                  if (mInvalidDatabaseFile) {
                    copyDatabase(DATABASE_NAME);
                  }
                } 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;
        }
       

        private SQLiteDatabase openDataBase(int flag) {

                SQLiteDatabase checkDB = null;

                try {

                        checkDB = getWritableDatabase();
                        checkDB.getPath();

                } catch (Exception e) {
                        e.printStackTrace();
                }

                return checkDB;
        }
       
       
       
        public SQLiteDatabase openDb() {

                SQLiteDatabase sqlDB = null;
                sqlDB = openDataBase(SQLiteDatabase.NO_LOCALIZED_COLLATORS);
       
               
                return sqlDB;

        }
       
        public void closeDb(SQLiteDatabase sqlDB) {

                sqlDB.close();               
        }
       
        public void copyDatabase(String DATABASE_NAME) {

                AssetManager assetManager = mContext.getResources().getAssets();
                  InputStream in = null;
                  OutputStream out = null;
                  try {
                    in = assetManager.open("Database/"+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) {
                          e.getStackTrace();
                  } 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();
                    }
                  }
        }
       
        public int getIdTimeCombo(String ora) {
                SQLiteDatabase sqlDB = null;
                Cursor data = null;
                try {
                        sqlDB = openDataBase(SQLiteDatabase.NO_LOCALIZED_COLLATORS);
                        int id=0;

                        data = sqlDB.rawQuery("SELECT ID FROM TIME_COMBO WHERE ID >= (SELECT ID FROM TIME_COMBO WHERE TIME LIKE                '"+ora+".00%') limit 1" , null);
                       
                        if (data.getCount() == 0)
                                return 0;

                        while (data.moveToNext()) {
                                id=data.getInt(0);
                        }
                        return (id);
                } catch (SQLiteException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                } finally {
                        if (data != null)
                                data.close();
                        if (sqlDB != null)
                                sqlDB.close();
                }
                return 0;
        }
       


       
        // esegui query
        public String execQuery(String query,SQLiteDatabase sqlDB) {

                try {
                        sqlDB.execSQL(query);

                } catch (Exception e) {
                        e.printStackTrace();
                } finally {

                }
                return null;
        }

       
}

---

CLASSE MIA:

codice:

---

public class SynchronizedActivity extends Activity{


        DatabaseHelper databaseHelper;
        String DATABASE_NAME="db.db";



        private boolean sincronizzazioneInCorso=false;
       
        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.syncro);

                databaseHelper = new DatabaseHelper(this,DATABASE_NAME);
                eseguitanteQuery();

        }

        private void eseguitanteQuery(){


                SQLiteDatabase sqlDB=databaseHelper.openDb();
                arrayQueryInsert=......;


                for(int i=0; i< arrayQueryInsert.length; i++) {

                        String query =arrayQueryInsert[i];       
                        databaseHelper.execQuery(query, sqlDB);

                }

                databaseSyncro.closeDb(sqlDB);
        }

}

---

Allora...

quando faccio 'databaseHelper = new DatabaseHelper(this,DATABASE_NAME);' entro nell'onCreate giusto?
Quindi utilizzo correttamente il DatabaseHelper o sbaglio qualcosa?

Poi per qualsiasi select utilizzo metodi tipo 'databaseHelper.getIdTimeCombo(parametro)',
mentre per far insert,update, delete utilizzo 'databaseHelper.execQuery(query, sqlDB)'.

Ho sempre fatto così ma mi piacerebbe imparare ad utilizzare gli statement e le transazioni.
Mi puoi aiutare facendo un esempio modificando il mio codice per le insert utilizzando statement e transazione?

Anche per le select mi puoi far un esempio come migliorare la velocità?
Grazie mille

---

Per migliorare la velocita' ti consiglio di applicare degli INDEX ai campi delle tue tabelle, in particolare ai campi che utilizzi nelle query...

per utilizzare al meglio gli statements, io ho creato una classe Database in questo modo:

codice:

---

public class SQLiteAdapter  {
 
 public static String DB_PATH = "/data/data/com.gestionechiamate.konvergence/";
 //public static String DB_PATH = Environment.getExternalStorageDirectory() + "/";
 public static final String MYDATABASE_NAME = "androidsqlitedb";
 public static final String MYDATABASE_TABLE = "Chiamate";
 public static final int MYDATABASE_VERSION = 1;
 public static final String KEY_CONTENT = "CodiceChiamata";
 
 private SQLiteHelper sqLiteHelper;
 private SQLiteDatabase sqLiteDatabase;
 private boolean sonoAperto;

 private Context context;
 
 public SQLiteAdapter(Context c){
  context = c;
 }
 //metodo per apertura database in sola lettura
 public SQLiteAdapter openToRead() throws android.database.SQLException, IOException {
          sqLiteHelper = new SQLiteHelper(context, DB_PATH + MYDATABASE_NAME, null, MYDATABASE_VERSION);
          sqLiteHelper.copyDatabase();
          sqLiteDatabase = sqLiteHelper.getReadableDatabase();
          sonoAperto = true; 
          return this;

 }
 //metodo per apertura database in lettura/scrittura
 public SQLiteAdapter openToWrite() throws android.database.SQLException, IOException {
  sqLiteHelper = new SQLiteHelper(context, DB_PATH + MYDATABASE_NAME, null, MYDATABASE_VERSION);
  sqLiteHelper.copyDatabase();
  sqLiteDatabase = sqLiteHelper.getWritableDatabase();
  sonoAperto = true;
  return this;
 }
 //metodo per chiusura database
 public void close(){
 
  sqLiteHelper.close();   
  sonoAperto = false;
 }
 
 public boolean checkSeAperto(){
        return sonoAperto;
 }

 public void queryInsertGenerica(String pQuery){
        sqLiteDatabase.execSQL(pQuery);
 }

 public Cursor selectAllChiamateOrderByCodiceChiamata(){       
        String query = "SELECT IdChiamata As _id, IdChiamata, CodiceChiamata, DataInserimento, DataRipristinoPrevisto, IdUbicazione, Contatto, IdInventario,Richiesta, Note, IdContrattoCliente, IdContrattoClienteSeverita, CodAttivita, CodCdc, Fatturabile, FatturabileFornitore, codiceEsterno FROM Chiamate order by dataInserimento desc";
        return sqLiteDatabase.rawQuery(query, null);       
 }

 public class SQLiteHelper extends SQLiteOpenHelper {

  public SQLiteHelper(Context cemptyontext, String name,
    CursorFactory factory, int version) {
  super(cemptyontext, name, factory, version);
  }

  @Override
  public void onCreate(SQLiteDatabase db) {

  }

  @Override
  public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

  } 
  public void copyDatabase() throws IOException {
          if (controlloEsistenzaDb()) {
          }else{
                InputStream assetsDB = context.getAssets().open("androidsqlitedb.s3db");
            //OutputStream dbOut = new FileOutputStream("/data/data/mia.applicazione.test/sqliteAndroid.db");
                OutputStream dbOut = new FileOutputStream(DB_PATH + "androidsqlitedb");
            byte[] buffer = new byte[1024];
            int length;
            while ((length = assetsDB.read(buffer))>0){
              dbOut.write(buffer, 0, length);
            }       
            dbOut.flush();
            dbOut.close();
            assetsDB.close();
          }
        }
  public boolean controlloEsistenzaDb()  {
  File dbFile = new File(DB_PATH + MYDATABASE_NAME);
  return dbFile.exists();
    } 
 }

---

Nota i metodi insertQueryGenerica e selectAllChiamateOrderByCodiceChiamata(), è un modo per eseguire get e set dal db direttamente utilizzando query in sql.

ciao, rispondo rapidamente alla parte sugli statement e transazioni.

una transazione e' un'operazione che ha le proprieta' ACID.
esempio di transazione, dal bulkInsert() di un mio Content Provider, che come vedi manca degli statements:

codice:

---

try {
        // TODO: add compiled statement if possible
        db.beginTransaction();
        for(ContentValues rowVals : values) {
                if (rowVals == null) throw new IllegalArgumentException("values of a bulk can't be null");
                checkRequiredValues(rowVals);
                populateDefaultValues(rowVals);
                db.insert(TABLE_SCHEMES, null, rowVals);
        }
        db.setTransactionSuccessful();
} finally {
        db.endTransaction();
}

---

db e' un database ottenuto con getWritableDatabase(). nota che manca il catch() perche' non mi interessava catturare le eccezioni, solo eseguire il finally. ma se volessi fare un rollback della transazione, dovresti farlo dentro il catch.

all'interno di quella transazione uno potrebbe usare un compiled statement, che e' uno statement "generico" che viene inviato al server sql, il quale lo mette in cache, e per eseguirlo devi solo passare i parametri particolari. un esempio e' il seguente:

codice:

---

SQLiteDatabase db = dbHelper.getWritableDatabase();
SQLiteStatement stmt = db.compileStatement("INSERT INTO Tabella (UserId, AttributeKey, AttributeValue) VALUES (?,?,?)");

// lego i valori ai punti di domanda, secondo l'ordine giusto
stmt.bindLong(1, userId);
stmt.bindString(2, key);
stmt.bindString(3, value);
stmt.executeInsert();

---

la parte in cui fai i binding e chiami execute() potrebbe essere all'interno di un ciclo, in modo da prendere i valori da una qualche lista.

nota pure che gli statement sono particolarmente utili per insert e update, per una select non mi viene in mente un caso utile (tra l'altro uno statement puo' ritornare un solo valore).

a proposito di select: con ottimizzarle intendevo solo che se devi prendere varie righe di una tabella, non le prendi una per una ma tutte insieme con un opportuna where.

Quote:

---

Originariamente inviato da Diegroid

ciao, rispondo rapidamente alla parte sugli statement e transazioni.

una transazione e' un'operazione che ha le proprieta' ACID.
esempio di transazione, dal bulkInsert() di un mio Content Provider, che come vedi manca degli statements:

codice:

---

try {
        // TODO: add compiled statement if possible
        db.beginTransaction();
        for(ContentValues rowVals : values) {
                if (rowVals == null) throw new IllegalArgumentException("values of a bulk can't be null");
                checkRequiredValues(rowVals);
                populateDefaultValues(rowVals);
                db.insert(TABLE_SCHEMES, null, rowVals);
        }
        db.setTransactionSuccessful();
} finally {
        db.endTransaction();
}

---

db e' un database ottenuto con getWritableDatabase(). nota che manca il catch() perche' non mi interessava catturare le eccezioni, solo eseguire il finally. ma se volessi fare un rollback della transazione, dovresti farlo dentro il catch.

all'interno di quella transazione uno potrebbe usare un compiled statement, che e' uno statement "generico" che viene inviato al server sql, il quale lo mette in cache, e per eseguirlo devi solo passare i parametri particolari. un esempio e' il seguente:

codice:

---

SQLiteDatabase db = dbHelper.getWritableDatabase();
SQLiteStatement stmt = db.compileStatement("INSERT INTO Tabella (UserId, AttributeKey, AttributeValue) VALUES (?,?,?)");

// lego i valori ai punti di domanda, secondo l'ordine giusto
stmt.bindLong(1, userId);
stmt.bindString(2, key);
stmt.bindString(3, value);
stmt.executeInsert();

---

la parte in cui fai i binding e chiami execute() potrebbe essere all'interno di un ciclo, in modo da prendere i valori da una qualche lista.

nota pure che gli statement sono particolarmente utili per insert e update, per una select non mi viene in mente un caso utile (tra l'altro uno statement puo' ritornare un solo valore).

a proposito di select: con ottimizzarle intendevo solo che se devi prendere varie righe di una tabella, non le prendi una per una ma tutte insieme con un opportuna where.

---

Grazie a tutti,

ho fatto un pò di chiarezza sul funzionamento del db.
Chiudo.

ultima domanda:
che dite.. DatabaseHelper è meglio statico o meglio fare una new nelle diverse Activity?

Quote:

---

Originariamente inviato da Rookye

ultima domanda:
che dite.. DatabaseHelper è meglio statico o meglio fare una new nelle diverse Activity?

---

qui c'e' un esempio d'uso corretto di SQLiteOpenHelper:
Creare ed usare database SQLite nelle applicazioni Android | devAPP

edit:
se non accedi da piu' di un thread contemporaneamente non serve avere un'unica istanza, va bene anche una per ogni activity.

Ma ancora una domanda per condividere tutti insieme la risposta..

La classe che estendiamo a DatabaseHelper secondo voi è meglio statica a fare una new nelle varie activity?
Direi meglio la new ma voi che ne pensate?

Che intendi con è meglio la new? Un oggetto inizializzato con new, che richiama il costruttore del tipo di classe a cui appartiene viene allocato in memoria.. devi trovare un giusto equilibrio di utilizzo... se vuoi fare una lavoro pulito puoi anche usare una istanza della classe DB per ogni activity ma è fondamentale gestire correttamente 'la fine' di quell'oggetto, sia nel codice operativo che nelle sue eccezioni soprattutto se fai uso di Cursor... un crash in fase di esecuzione con un cursore aperto può anche corrompere il file del tuo db SQLite :)

Inviato dal mio Galaxy Nexus con Tapatalk 2