Create Table che falliscono

[Rookye]

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

[Rookye]

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

[frank17next]

Ciao,

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

Grazie,
Ciao

[ParanoidAndroid.it]

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

[Rookye]

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.

 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...

[ParanoidAndroid.it]

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.

[Rookye]

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

CLASSE DATABASEHELPER:

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:

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

[frank17next]

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

CLASSE DATABASEHELPER:

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:

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:

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.

[ParanoidAndroid.it]

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:

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:

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.

[Rookye]

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:

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:

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.