PDM Avanzado Datos Bases de datos

De Manuais Informática - IES San Clemente.
Revisión del 18:16 30 abr 2015 de Angelfg (discusión | contribuciones) (Xuntando todo cos Modelos)
(dif) ← Revisión anterior | Revisión actual (dif) | Revisión siguiente → (dif)
Ir a la navegación Ir a la búsqueda

Introdución

Información adicional: http://developer.android.com/guide/topics/data/data-storage.html

Android permite manexar bases de datos SQLite.

Neste curso partimos de que o alumno coñece o que é unha base de datos relacional e todo o que leva consigo (claves primarias, atributos, nulos, sentenzas SQL,...)

Máis información: http://es.wikipedia.org/wiki/Base_de_datos_relacional

Creación dunha base de datos

O primeiro que temos que facer é crear unha clase que herde da clase abstracta SQLiteOpenHelper.

Nota: Podemos facelo nun paquete separado para dar maior claridade ao noso proxecto.

Ao facelo, o Eclipse, obrigaranos a crear un construtor e uns métodos asociados á clase abstracta SQLiteOpenHelper.

Ao final de todo teremos o seguinte código, partindo que a clase que creamos ten de nome BaseDatos:

 1 import android.content.Context;
 2 import android.database.sqlite.SQLiteDatabase;
 3 import android.database.sqlite.SQLiteDatabase.CursorFactory;
 4 import android.database.sqlite.SQLiteOpenHelper;
 5 
 6 public class BaseDatos extends SQLiteOpenHelper{
 7 
 8 	public BaseDatos(Context context, String name, CursorFactory factory,
 9 			int version) {
10 		super(context, name, factory, version);
11 		// TODO Auto-generated constructor stub
12 	}
13 
14 	@Override
15 	public void onCreate(SQLiteDatabase db) {
16 		// TODO Auto-generated method stub
17 		
18 	}
19 
20 	@Override
21 	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
22 		// TODO Auto-generated method stub
23 		
24 	}
25 }


Analicemos o construtor.

1 	public BaseDatos(Context context, String name, CursorFactory factory,
2 			int version) {
3 		super(context, name, factory, version);
4 		// TODO Auto-generated constructor stub
5 	}


Ten catro parámetros:

  • Context context: O contexto da Activity.
  • String name: O nome da base de datos a abrir.
  • CursorFactory factory: Este valor normalmente leva null xa que é utilizado cando queremos facer consultas que devolvan Cursores que nos van permitir acceder ós datos dunha consulta de forma aleatoria.
  • int version: Versión da base de datos. Verémolo despois.

Para facer máis sinxelo o construtor ímolo modificar e deixarémolo así:

1 	public final static String NOME_BD="basedatos";
2 	public final static int VERSION_BD=1;
3 	
4 	public BaseDatos(Context context) {
5 		super(context, NOME_BD, null, VERSION_BD);
6 		// TODO Auto-generated constructor stub
7 	}

Cando dende a nosa Activity cremos un obxecto desta clase e abrimos a base de datos, chamará ós métodos onCreate ou onUpgrade segundo os casos.

  • Se a base de datos non existe, chamará ao método onCreate. Será dentro deste método onde se poñan as ordes para crear as diferentes táboas da nosa base de datos.
  • Se a base de datos xa existe, e a versión da base de datos é diferente, chamará ao método onUpgrade. Será dentro deste método onde poñamos as ordes de modificación das táboas da nosa base de datos.


Poñamos un exemplo:

  • Un usuario descarga a nosa aplicación do Market e empeza a traballar con ela. A primeira vez chamará ao método onCreate e xeraranse as táboas necesarias.
  • Cando leva un tempo traballando coa aplicación (engadiu datos ás táboas), decide actualizar a nosa aplicación. Imaxinemos que na actualización, necesitamos engadir unha táboa nova.
    • Como a base de datos xa existe, non vai pasar polo método onCreate.
    • Como facemos para engadir a nova táboa?
      • Cambiamos o número de versión da base de datos e subindo a aplicación compilada ao Market.
      • Cando o usuario descargue a aplicación actualizada executará o método onUpgrade e é nese método onde teremos a creación da nova táboa.
      • Os datos non almacenados non se perden.


Nota: Veremos máis adiante que cando se crea a base de datos, gárdase no cartafol /data/data/paquete_aplicación/databases/

Normalmente a base de datos xa a teremos feita (cunha ferramenta externa) e o que facemos é copiala a dito cartafol. Cando o usuario abra a base de datos xa non vai pasar polo método onCreate.


Para que se chamen a ditos procedementos (onCreate / onUpgrade) será necesario crear un obxecto da clase que deriva de SQLiteOpenHelper e chamar a un destes métodos:


Manualmente

Debemos crear e sobrescribir o método onCreate para crear as táboas que conforman a base de datos.

Dito método (onCreate) trae como parámetro un obxecto da clase SqLiteDatabase que posúe o método execSQL para lanzar as ordes SQL necesarias.

Máis información sobre a orde Create Table: https://www.sqlite.org/lang_createtable.html

Se necesitamos modificar as táboas ou crear novas deberemos sobrescribir o método onUpgrade.


Manual: Caso práctico

Nesta práctica imos crear unha base de datos cunha táboa.

Para facelo teremos que abrir a base de datos en modo lectura ou lectura/escritura como xa comentamos. Neste exemplo vaise abrir en modo lectura/escritura.


Aviso Se o alumno está a probar a aplicación nun dispositivo real non hai opción de comprobar se e base de datos está creada a no ser que o dispositivo físico estea rooteado.

Creamos a Activity Principal
  • Nome do proxecto: UD1_04_DatosPersistentes_BD
  • Nome da activity: UD1_04_DatosPersistentes_BD.java


Código xml do layout

 1 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 2     xmlns:tools="http://schemas.android.com/tools"
 3     android:layout_width="match_parent"
 4     android:layout_height="match_parent"
 5     tools:context="${relativePackage}.${activityClass}" >
 6 
 7     <Button
 8         android:id="@+id/UD1_04_btnCrearBD"
 9         android:layout_width="wrap_content"
10         android:layout_height="wrap_content"
11         android:layout_centerHorizontal="true"
12         android:layout_centerVertical="true"
13         android:text="CREAR BASE DE DATOS" />
14 
15 </RelativeLayout>


Código da clase UD1_04_DatosPersistentes_BD
Obxectivo: Crear unha base de datos.

 1 import android.app.Activity;
 2 import android.os.Bundle;
 3 import android.view.View;
 4 import android.view.View.OnClickListener;
 5 import android.widget.Button;
 6 import android.widget.Toast;
 7 
 8 #OLLO! hai que cambiar a seguinte liña para importar dende o paquete correcto.
 9 import com.platega.......basedatos.UD1_04_BASEDATOS;
10 
11 public class UD1_04_DatosPersistentes_BD extends Activity {
12 	private UD1_04_BASEDATOS ud1_04_baseDatos;
13 	
14 	private void xestionarEventos(){
15 	
16 		Button btnCrearBD = (Button)findViewById(R.id.UD1_04_btnCrearBD);
17 		btnCrearBD.setOnClickListener(new OnClickListener() {
18 			
19 			@Override
20 			public void onClick(View v) {
21 				// TODO Auto-generated method stub
22 			
23 				ud1_04_baseDatos = new UD1_04_BASEDATOS(getApplicationContext());
24 				ud1_04_baseDatos.getWritableDatabase();
25 				
26 				Toast.makeText(getApplicationContext(), "BASE DE DATOS CREADA", Toast.LENGTH_LONG).show();
27 			}
28 		});
29 		
30 	}
31 	
32 	@Override
33 	protected void onCreate(Bundle savedInstanceState) {
34 		super.onCreate(savedInstanceState);
35 		setContentView(R.layout.activity_ud1_04__datos_persistentes_bd);
36 		
37 		xestionarEventos();
38 	}
39 }
  • Liña 12: Creamos unha propiedade que vai servir para poder realizar operacións contra a base de datos.
  • Liña 23: Instanciamos a propiedade.
  • Liña 24: Abrimos a base de datos para operacións de escritura / lectura. É agora cando, se a base de datos non existe, chamará o método onCreate.
Creamos a clase que vai xestionar a BD

Neste exemplo imos crear unha clase de nome UD1_04_BASEDATOS que derive da clase SQLiteOpenHelper como explicamos antes.

  • O nome da base de datos será UD1_04_BDEXEMPLO
  • Faremos que no método onCreate se cre a seguinte táboa:
  • Táboa: AULAS (_id integer autonumérico clave primaria, nome varchar(50))
  • A modo de exemplo, faremos que no método onUpgrade se borren todas as táboas e se volvan crear.


Creamos a clase UD1_04_BASEDATOS:

Código da clase UD1_04_BASEDATOS
Obxectivo: Clase que vai executar as ordes para a creación das táboas e operacións contra a base de datos (SELECT, UPDATE, DELETE).

 1 import android.content.Context;
 2 import android.database.sqlite.SQLiteDatabase;
 3 import android.database.sqlite.SQLiteOpenHelper;
 4 
 5 public class UD1_04_BASEDATOS extends SQLiteOpenHelper{
 6 
 7 	public final static String NOME_BD="UD1_04_BDEXEMPLO";
 8 	public final static int VERSION_BD=1;
 9 	
10 	private String CREAR_TABOA_AULAS ="CREATE TABLE AULAS ( " + 
11 							"_id  INTEGER PRIMARY KEY AUTOINCREMENT," +
12 							"nome VARCHAR( 50 )  NOT NULL)";
13 	
14 	
15 	public UD1_04_BASEDATOS(Context context) {
16 		super(context, NOME_BD, null, VERSION_BD);
17 		// TODO Auto-generated constructor stub
18 	}
19 
20 	@Override
21 	public void onCreate(SQLiteDatabase db) {
22 		// TODO Auto-generated method stub
23 		db.execSQL(CREAR_TABOA_AULAS);
24 
25 	}
26 
27 	@Override
28 	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
29 		// TODO Auto-generated method stub
30 		
31 		db.execSQL("DROP TABLE IF EXISTS AULAS");
32 		onCreate(db);
33 	}
34 
35 }


Se executamos máis veces a aplicación non vai volver a executar o método onCreate xa que a base de datos está creada.
Teríamos que desinstalar a aplicación ou cambiar o número de versión da base de datos (iría ao método onUpgrade).

Ferramenta externa: SqliteStudio

Normalmente, cando creamos a nosa aplicación e vai utilizar unha base de datos, non imos creala no método onCreate mediante ordes CREATE TABLE.

O lóxico será tela creada cuns datos iniciais.

Esta base de datos se atopará nun cartafol (por exemplo /assets/) e copiaremos a base de datos dende /assets/ ao cartafol onde Android busca a base de datos.


Para crear a base de datos temos moitas ferramentas gratuítas para facelo.

Por exemplo: http://sqlitestudio.pl/


Nota: Se estamos a utilizar Linux deberemos darlle permiso de execución ao arquivo baixado coa orde:

	 chmod 755 sqlitestudio-2.1.4.bin

e despois executala:

	 ./sqlitestudio-2.1.4.bin


  • Unha vez no programa podemos crear unha base de datos nova indo o menú Base de datos => Engadir Base de datos.

PDM Avanzada DatosPersistentes 24.jpg

Aquí temos que indicar o sitio físico onde se vai gardar / abrir a base de datos e o nome da mesma.
A versión poñeremos sqlite3.
Debemos premer o botón de 'Ok'.


  • Agora debemos de escoller a opción de Tablas e unha vez escollida premer a opción Nueva Tabla da parte superior.

PDM Avanzada DatosPersistentes 25.jpg


  • Esta pantalla é bastante intuitiva.
  • Damos un nome á táboa (no exemplo AULAS) e prememos o botón 'Añadir Columna'.

PDM Avanzada DatosPersistentes 26.jpg


  • Agora só temos que engadir as columnas co tipo de dato adecuado:

PDM Avanzada DatosPersistentes 27.jpg

Se prememos na opción configurar podemos facer varias cousas dependendo do que teñamos escollido.
Por exemplo:
  • Na clave primaria: podemos facer que o campo sexa autonumérico. Quere isto dicir que cando engadimos unha nova fila non é necesario darlle un valor a dita columna xa que vai xerar automaticamente un valor.
  • No valor por defecto: podemos especificar o valor que terá dita columna na fila se non enviamos ningún.
Unha vez temos todos os campo debemos premer o botón de Crear (na imaxe aparece cambiar porque xa estaba creada):

PDM Avanzada DatosPersistentes 28.jpg


  • Unha vez creada a táboa xa podemos engadir filas ou modificar os campos premendo sobre a pestana de datos:

PDM Avanzada DatosPersistentes 29.jpg


  • Temos que premer sobre o botón Máis, engadir os datos e ao rematar de engadir as filas, premer sobre o botón Commit:

PDM Avanzada DatosPersistentes 30.jpg


Copiando a base de datos dende /assets/ a .../databases/

Como comentamos antes, a base de datos podemos tela xa creada e con datos preparada para ser utilizada pola nosa aplicación.

Para que esta poida utilizala teremos que copiala ao cartafol /data/data/paquete_aplicación/databases/

A forma de copiala xa a vimos cando vimos o apartado de xestión de arquivos.

Normalmente a copia debería facerse nun fío separado do fío principal. O uso dos fíos xa verémolo na unidade 3.


O único que temos que ter coidado é que se copiamos a base de datos, o cartafol .../databases/ non está creado e teremos que crealo nos.

Fisicamente as bases de datos se crean no cartafol /data/data/nome do paquete/databases/NOME BD.

Se queremos ter unha referencia ao obxecto File que apunte á nosa base de datos podemos usar a chamada:

getDatabasePath(NOME_BD)

ou ben ter unha referencia ao seu path e partires del obter un obxecto da clase File:

String pathbd = "/data/data/" + getApplicationContext().getPackageName()+"/databases/";


Como comentamos antes o normal é ter a base de datos creada no cartafol /assets/ e copiala o cartafol /databases/.

  • Se o facemos así será necesario crear previamente dito cartafol /databases/:
1 String pathbd = "/data/data/" + contexto.getPackageName()+"/databases/";
2 File ruta = new File(pathbd);
3 ruta.mkdirs();


  • Unha vez creado o cartafol xa podemos copiar a base de datos. Neste exemplo non se usa un fío de execución.
Comprobamos se existe a base de datos previamente, xa que se non, cada vez que iniciáramos a aplicación borraríamos a base de datos.
1 		String bddestino = "/data/data/" + getPackageName() + "/databases/"
2 				+ UD1_05_BASEDATOS.NOME_BD;
3 		File file = new File(bddestino);
4 		if (file.exists())
5 			return; // XA EXISTE A BASE DE DATOS

Copiamos a base de datos.

 1 		String pathbd = "/data/data/" + getPackageName()
 2 				+ "/databases/";
 3 		File filepathdb = new File(pathbd);
 4 		filepathdb.mkdirs();
 5 
 6 		InputStream inputstream;
 7 		try {
 8 			inputstream = getAssets().open(UD1_05_BASEDATOS.NOME_BD);
 9 			OutputStream outputstream = new FileOutputStream(bddestino);
10 
11 			int tamread;
12 			byte[] buffer = new byte[2048];
13 
14 			while ((tamread = inputstream.read(buffer)) > 0) {
15 				outputstream.write(buffer, 0, tamread);
16 			}
17 
18 			inputstream.close();
19 			outputstream.flush();
20 			outputstream.close();
21 		} catch (IOException e) {
22 			// TODO Auto-generated catch block
23 			e.printStackTrace();
24 		}



Caso práctico

Imos copiar unha base de datos feita coa ferramenta anterior dende o cartafol /assets/ ao cartafol /databases/.

Preparación

Hai que descomprimir e copiar o seguinte arquivo ao cartafol /assets/ do voso proxecto.

Media:PDM_UD1_05_BDEXEMPLO.zip

Nota: O alumno pode utilizar a súa propia base de datos xerada coa ferramenta anterior.

Creamos a Activity
  • Nome do proxecto: UD1_05_DatosPersistentes_BD
  • Nome da activity: UD1_05_DatosPersistentes_BD.java


Código do layout xml

 1 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 2     xmlns:tools="http://schemas.android.com/tools"
 3     android:layout_width="match_parent"
 4     android:layout_height="match_parent"
 5     tools:context="${relativePackage}.${activityClass}" >
 6 
 7   <Button
 8         android:id="@+id/UD1_05_btnAbrirBD"
 9         android:layout_width="wrap_content"
10         android:layout_height="wrap_content"
11         android:layout_centerHorizontal="true"
12         android:layout_centerVertical="true"
13         android:text="ABRIR BASE DE DATOS" />
14 
15 
16 </RelativeLayout>


Código da clase UD1_05_DatosPersistentes_BD
Obxectivo: Copiar unha base de datos dende /assets/ ao cartafol /databases/.

 1 import java.io.File;
 2 import java.io.FileOutputStream;
 3 import java.io.IOException;
 4 import java.io.InputStream;
 5 import java.io.OutputStream;
 6 
 7 import android.app.Activity;
 8 import android.os.Bundle;
 9 import android.view.View;
10 import android.view.View.OnClickListener;
11 import android.widget.Button;
12 import android.widget.Toast;
13 
14 import com.platega.angel.datospersistentes.basedatos.UD1_05_BASEDATOS;
15 
16 public class UD1_05_DatosPersistentes_BD extends Activity {
17 
18 	private UD1_05_BASEDATOS ud1_05_baseDatos;
19 
20 
21 	private void copiarBD() {
22 		String bddestino = "/data/data/" + getPackageName() + "/databases/"
23 				+ UD1_05_BASEDATOS.NOME_BD;
24 		File file = new File(bddestino);
25 		if (file.exists()) {
26 			Toast.makeText(getApplicationContext(), "A BD NON SE VAI COPIAR. XA EXISTE", Toast.LENGTH_LONG).show();
27 			return; // XA EXISTE A BASE DE DATOS
28 		}
29 
30 		String pathbd = "/data/data/" + getPackageName()
31 				+ "/databases/";
32 		File filepathdb = new File(pathbd);
33 		filepathdb.mkdirs();
34 
35 		InputStream inputstream;
36 		try {
37 			inputstream = getAssets().open(UD1_05_BASEDATOS.NOME_BD);
38 			OutputStream outputstream = new FileOutputStream(bddestino);
39 
40 			int tamread;
41 			byte[] buffer = new byte[2048];
42 
43 			while ((tamread = inputstream.read(buffer)) > 0) {
44 				outputstream.write(buffer, 0, tamread);
45 			}
46 
47 			inputstream.close();
48 			outputstream.flush();
49 			outputstream.close();
50 			Toast.makeText(getApplicationContext(), "BASE DE DATOS COPIADA", Toast.LENGTH_LONG).show();
51 		} catch (IOException e) {
52 			// TODO Auto-generated catch block
53 			e.printStackTrace();
54 		}
55 
56 	}
57 
58 	private void xestionarEventos(){
59 	
60 		Button btnAbrirBD = (Button)findViewById(R.id.UD1_05_btnAbrirBD);
61 		btnAbrirBD.setOnClickListener(new OnClickListener() {
62 			
63 			@Override
64 			public void onClick(View v) {
65 				// TODO Auto-generated method stub
66 			
67 
68 				ud1_05_baseDatos = new UD1_05_BASEDATOS(getApplicationContext());
69 				ud1_05_baseDatos.getWritableDatabase();
70 				
71 				Toast.makeText(getApplicationContext(), "BASE DE DATOS ABERTA", Toast.LENGTH_LONG).show();
72 			}
73 		});
74 		
75 	}
76 	
77 	@Override
78 	protected void onCreate(Bundle savedInstanceState) {
79 		super.onCreate(savedInstanceState);
80 	        setContentView(R.layout.activity_ud1_05__datos_persistentes__bd);
81 		
82 		xestionarEventos();
83 		copiarBD();
84 	}
85 }
  • Liñas 21-56: Procedemento para copiar a base de datos.
  • Liñas 25-28: Miramos se a base de datos existe. Neste exemplo non a copiamos se existe. Nunha aplicación real poderíamos enviar un parámetro para indicar se queremos sobreesribila xa que pode ser necesario se queremos 'inicializar' a aplicación.
  • Liñas 63-73: Xestionamos o evento de click sobre o botón de abrir. Como a base de datos xa está copiada podemos utilizala.
Creamos a clase que xestionará a Base de Datos

Importante: Fixarse como non facemos ningún 'create table' no método onCreate.

Isto é así xa que a base de datos xa vai estar creada no cartafol /assets/

Código da clase UD1_05_BASEDATOS

 1 import android.content.Context;
 2 import android.database.sqlite.SQLiteDatabase;
 3 import android.database.sqlite.SQLiteOpenHelper;
 4 
 5 public class UD1_05_BASEDATOS extends SQLiteOpenHelper{
 6 
 7 	public final static String NOME_BD="UD1_05_BDEXEMPLO";
 8 	public final static int VERSION_BD=1;
 9 	
10 	
11 	public UD1_05_BASEDATOS(Context context) {
12 		super(context, NOME_BD, null, VERSION_BD);
13 		// TODO Auto-generated constructor stub
14 	}
15 
16 	@Override
17 	public void onCreate(SQLiteDatabase db) {
18 		// TODO Auto-generated method stub
19 
20 	}
21 
22 	@Override
23 	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
24 		// TODO Auto-generated method stub
25 		
26 	}
27 
28 }

Xestionar a base de datos dende consola

Se estamos a utilizar o emulador ou podemos ser root no dispositivo real, podemos conectarnos á base de datos dende consola.

O proceso é o seguinte:

  • Abrimos un terminal (linux) ou consola (windows).
  • Facemos un cd do caratafol onde está instalado o SDK e dentro deste ir ao cartafol /sdk/plataform-tools/.
Se listades os arquivo vos debe aparecer un executable de nome 'adb'.
  • Dende a consola deberedes escribir:
  • adb shell (WINDOWS)
  • ./adb shell (LINUX)
  • Unha vez no shell, conectamos coa base de datos escribindo:
  • sqlite3 /data/data/o_voso_paquete/databases/NOME_BASEDATOS
  • Agora estamos conectados a SQLIte e podemos executar ordes SQL (deben acabar en ; ).
Por exemplo:
  • .tables : lista as táboas.
  • SELECT * FROM NOME_TABOA; (amosa os datos)
  • Para saír do sqlite poñeremos:
.exit
  • Para saír do adb shell:
exit



Nota: Coidado cas maiúsculas / minúsculas.

Operacións sobre unha base de datos

Introdución

As operacións que imos facer sobre a base de datos son:

  • SELECT: Selección.
  • UPDATE: Actualización.
  • DELETE: Borrado.

Nota: Neste curso consideramos que os alumnos teñen coñecementos para entender as ordes SQL que dan soporte a estas operacións.


Para poder realizar as operacións anteriormente comentadas imos necesitar facer uso dun obxecto da clase SQLiteDatabase.

Podemos obtelo de dúas formas:

  • Dito obxecto o temos como parámetro no método onCreate e no método onUpgrade da clase que deriva de SQLiteOpenHelper:
 1 	@Override
 2 	public void onCreate(SQLiteDatabase db) {
 3 		// TODO Auto-generated method stub
 4 
 5 	}
 6 
 7 	@Override
 8 	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
 9 		// TODO Auto-generated method stub
10 		
11 	}
Polo tanto podemos facer uso do obxecto db para realizar as operacións SQL. Nestes métodos normalmente utilizaranse cando non se fai o proceso de copia da base de datos e estamos a crear a base de datos manualmente con ordes 'create table'.
  • Cando abrimos a base de datos para escribir ou para ler:
1 SQLiteDatabase sqlLiteDB = ud4_05_baseDatos.getWritableDatabase();
Nota: Código baseado a partires do exemplo anterior.

Agora con dito obxecto podemos facer as operacións SQL.

INSERT

Engadir unha nova fila.

Máis información en: http://www.w3schools.com/sql/sql_insert.asp

Temos dúas formas de engadir datos:

  • Utilizando a orden INSERT de SQL:
1 sqlLiteDB.execSQL("INSERT INTO NOME_TABOA (campo1,campo2,....) VALUES ('valor1','valor2',....)");

Nota: Os valores numéricos non levan comillas.


  • A segunda forma é utilizando un obxecto da clase ContentValues, o cal garda pares da forma clave-valor, e no noso caso, serán pares nome_columna-valor.

Chamaremos despois aos métodos insert(), update() e delete() da clase SQLiteDatabase.

Por exemplo:

1 		ContentValues datosexemplo = new ContentValues();
2 		datosexemplo.put("NOME_COL1", "Valor col1_a");
3 		datosexemplo.put("NOME_COL2", "Valor_col2_a");
4 		long idFila1 = sqlLiteDB.insert(NOME_TABOA, null, datosexemplo);
5 		
6                 datosexemplo.clear();
7 		datosexemplo.put("NOME_COL1", "Valor col1_b");
8 		datosexemplo.put("NOME_COL2", "Valor_col2_b");
9 		long idFila2 = sqlLiteDB.insert(NOME_TABOA, null, datosexemplo);


  • O segundo parámetro leva de valor null, xa que só se usa en contadas ocasións, coma por exemplo, para engadir rexistros baleiros.
  • Neste exemplo supoñemos que a táboa onde se van engadir os rexistros ten de clave primaria un campo autonumérico.
  • O método insert devolve o id da fila engadida (a clave principal é autonumérica) ou -1 se hai un erro.

UPDATE

Actualiza datos.

Máis información en: http://www.w3schools.com/sql/sql_update.asp

O método update() leva como terceiro parámetro a condición que teñen que cumprir as filas.

1 ContentValues datosexemplo = new ContentValues();
2 datosexemplo.put("COLUMNA_MODIFICAR","TEXTO NOVO"); 
3 String condicionwhere = "COL1=?";
4 String[] parametros = new String[]{'Texto a buscar'};
5 int rexistrosafectados = sqlLiteDB.update(NOME_TABOA,datosexemplo,condicionwhere,parametros);

Se queremos unha condición composta (por exemplo con AND):

1 ContentValues datosexemplo = new ContentValues();
2 datosexemplo.put("COLUMNA_MODIFICAR","TEXTO NOVO"); 
3 String condicionwhere = "COL1=? AND COL2=?";
4 String[] parametros = new String[]{'Texto1','Texto2'};
5 int rexistrosafectados = sqlLiteDB.update(NOME_TABOA,datosexemplo,condicionwhere,parametros);

Nun exemplo concreto:

TÁBOA AULAS (_id, nome):

Esta consulta sql:

1 UPDATE AULAS
2 SET nome='Novo nome'
3 WHERE _id=5;

Pasará a ser:

1 ContentValues datos = new ContentValues();
2 datos.put("nome","Novo nome"); 
3 String condicionwhere = "_id=?";
4 String[] parametros = new String[]{String.valueOf(5)};
5 int rexistrosafectados = sqlLiteDB.update("AULAS",datos,condicionwhere,parametros);


Aquí hai que sinalar varios aspectos:

  • Se queremos poñer unha condición a un campo de tipo texto NON teremos que poñer o parámetro entre comiñas:
    • NOME + "=?" (Correcto)
    • NOME + "='?'" (Incorrecto)
  • Se o facemos directamente na orde SQL entón si que as levaría:
String CONSULTA="SELECT id,nome FROM CLASES WHERE nome = 'AULA 1'";
  • Cada '?' se corresponde cun dato do array de parámetros. No noso exemplo enviamos o ID que teremos que converter a String:
String[] parametros = new String[]{String.valueOf(5)};
  • O método update devolve o número de filas afectadas ou -1 en caso de erro.

DELETE

Borra filas.

Máis información: http://www.w3schools.com/sql/sql_delete.asp

O método delete() é parecido ao anterior.

Pásase como primeiro parámetro a táboa e como segundo a condición que teñen que cumprir as filas para ser borradas:

1 String condicionwhere = "COL1=?";
2 String[] parametros = new String[]{'Valor a buscar'};
3 int rexistrosafectados = sqlLiteDB.delete(NOME_TABOA,condicionwhere,parametros);


  • O método delete devolve o número de filas afectadas ou -1 en caso de erro.
  • Os conceptos da cláusula Where son os mesmos que no caso do Update.


Nun exemplo concreto:

TÁBOA AULAS (_id, nome):

Esta consulta sql:

1 DELETE FROM AULAS 
2 WHERE _id=5;

Pasará a ser:

1 String condicionwhere = "_id=?";
2 String[] parametros = new String[]{String.valueOf(5)};
3 int rexistrosafectados = sqlLiteDB.delete("AULAS",condicionwhere,parametros);

SELECT

A selección de filas leva consigo que o resultado vai poder traer de volta moitas filas.

Veremos máis adiante como devolver esas filas como se foran un Array de obxectos.


Para facer consultas á base de datos podemos utilizar dous métodos da clase SQLiteQueryBuilder : rawQuery e query

  • rawQuery
A diferenza vai estar na forma de facer a chamada, xa que rawQuery deixa enviar a orde SQL e query utiliza outra estrutura de chamada.
Por exemplo:
1   Cursor cursor = sqlLiteDB.rawQuery("select _id,nome from AULAS where _id = ?", new String[] { String.valueOf(5) });
  • O segundo parámetro é un array de Strings no caso de que a consulta leve parámetros (símbolo ?).
  • query
1 Cursor cursor = sqlLiteDB.query(DATABASE_TABLE, 
2   new String[] { col1,col2,... }, 
3   null, null, null, null, null);
Os parámetros en query son:
  • DATABASE_TABLE: Nome da táboa.
  • Lista de columnas, nun array de String. Se poñemos null devolve todas.
  • Cláusula where
  • Array de string no caso de que a cláusula where leve parámetros da forma ‘id=?’, é dicir, co caracter ?.
  • Array de String onde irán os nomes das columnas para facer group by.
  • Array de String onde irán os nomes das columnas para facer having.
  • Array de String onde irán os nomes das columnas para facer order by.
Por exemplo, a orde SQL:
SELECT nome FROM AULAS
sería:
1 Cursor cursor = sqlLiteDB.query("AULAS", 
2   new String[] { nome }, 
3   null, null, null, null, null);

Nos imos a usar a primeira opción.


Os dous tipos de consultas (rawquery e query) devolven un obxecto Cursor. Para saber o nº de filas devoltas temos o método getCount() e dispoñemos de diferentes métodos para movernos polas filas do cursor.

O proceso normalmente será o de percorrer todo o cursor e devolver un ArrayList dun tipo determinado (verase despois).

1   Cursor cursor = sqlLiteDB.rawQuery("select _id,nome from AULAS", null); 
2   if (cursor.moveToFirst()) {                // Se non ten datos xa non entra
3 	while (!cursor.isAfterLast()) {     // Quédase no bucle ata que remata de percorrer o cursor. Fixarse que leva un ! (not) diante
4 		long id =cursor.getLong(0);
5                 String nome = cursor.getString(1);
6 		cursor.moveToNext();
7 	}
8   }
Dentro do bucle temos acceso ós datos de cada fila.
Cada columna da consulta está referenciada por un número, empezando en 0 (a columna _id correspóndese coa número 0 e a columna nome coa número 1). Isto é asi porque no select están nesa orde.


MOI IMPORTANTE: Cando rematemos de procesar a fila teremos que pasar á seguinte dentro do cursor e temos que chamar ó método moveToNext(). Se non o facemos quedaremos nun bucle infinito.
Neste exemplo non estamos a facer nada con cada fila devolta. Poderíamos ter una Array e ir engadindo a dito Array os valores que devolve a consulta, pero veremos a continuación que é mellor facelo utilizando obxectos.





Aclaración: Cando creamos a táboa AULAS puxemos como clave primaria _id. Por que utilizar un guión baixo e ese nome ?
Porque unha consulta á base de datos pode devolver directamente o Cursor con todos os datos e 'cargar' ditos datos nun adaptador especial denominado SimpleCursorAdapter] e asociar dito Adaptador a un elemento gráfico como unha lista.
Por exemplo:
1 SimpleCursorAdapter mAdapter = new SimpleCursorAdapter(this,R.layout.list_layout_creado, cursor, new String[] { "nome" },new int[] { android.R.id.text1});
Sendo:
  • 'list_layout_creado': O layout que vai amosar a ListView.
  • cursor: Os datos devoltos pola base de datos de todas as aulas.
  • android.R.id.text1: Un TextView definido dentro do layout 'list_layout_creado'.
Lembrar que xa vimos o uso de adaptadores no curso de Iniciación.



Onde facer as operacións

Neste curso imos facer as operacións contra a base de datos na clase que deriva da clase abstracta SQLiteOpenHelper (onde se atopan os métodos onCreate e onUpgrade).

Poderíamos facelo na activity a partires de obter o obxecto sqlLiteDB, pero desta forma quedará moito máis claro.


Polo tanto imos ter que gardar o obxecto sqlLiteDB na propia clase para poder ter acceso a el e poder facer as operacións.

Unha forma de facelo é a seguinte:

  • Definimos unha propiedade public dentro da clase SQLiteOpenHelper.
public class UD1_06_BASEDATOS extends SQLiteOpenHelper{

	public SQLiteDatabase sqlLiteDB;
        ...............


  • Cando dende a Activity abrimos a base de datos, ao mesmo tempo gardamos a referencia que nos devolve o método getWritableDatabase():
1 public class UD1_06_DatosPersistentes_BD extends Activity {
2         ...............
3 	ud1_06_baseDatos = new UD1_06_BASEDATOS(getApplicationContext());
4 	ud1_06_baseDatos.sqlLiteDB = ud1_06_baseDatos.getWritableDatabase();
  • Agora definimos os método que necesitemos para dar soporte á nosa aplicación.

Xuntando todo cos Modelos

Normalmente os datos dunha base de datos os imos 'modelizar' en forma de clases.

Así, se se ten unha táboa AULAS poderase modelizar utilizando unha clase AULAS que teña como propiedades as columnas da táboa.


Non pretendemos entrar a explicar o UML e o Diagrama de Clases.

Tampouco imos traballar con capas intermedias. Atoparedes manuais nos que se crea unha clase 'Adaptadora' que é a que traballa con ContentValues' e Cursors. Por enriba desta clase atoparíase unha clase 'de xestión' que sería a que exporía os métodos para facer operacións dende a interface do usuario e que convertía un obxecto da clase Aula a ContentValues, para ser engadida á base de datos (por exemplo) e tamén o proceso contrario, pasar de, por exemplo, un Cursor a un array de obxectos da clase Aulas.



Imos velo cun exemplo concreto:

  • TÁBOA AULAS: (_id, nome)
  • Definimos a clase que vai gardar esta información: Aulas
 1 public class Aulas {
 2 
 3 	private long _id;
 4 	private String nome;
 5 	
 6 	public Aulas (long id, String nome){
 7 		this._id=id;
 8 		this.nome=nome;
 9 	}
10 	
11 	public long get_id() {
12 		return _id;
13 	}
14 	public void set_id(long _id) {
15 		this._id = _id;
16 	}
17 	public String getNome() {
18 		return nome;
19 	}
20 	public void setNome(String nome) {
21 		this.nome = nome;
22 	}
23 	
24 	public String toString(){
25 		return nome;
26 	}
27 }

NOTA IMPORTANTE: Definimos o método toString() xa que imos 'cargar' ós elementos gráficos (como as listas=> ListView) con array de obxectos. Neses casos o elemento gráfico (a lista) amosa o que devolva o método toString().

NOTA:: Dentro de Android hai artigos que indican que facer métodos get e set para acceder as propiedades degradan o rendemento da aplicación e que sería conveniente acceder directamente ás propiedades (facéndoas public). En todas as aplicacións que levo feitas non atopei ese 'rendemento inferior' polo que supoño que só será apreciable en aquelas aplicacións que fagan un uso moi intensivo de datos.

  • Agora que temos definida a clase podemos definir os métodos que imos necesitar.

Nota: Lembrar que as operacións contra a base de datos se definirán na clase que deriva de SQLiteOpenHelper (onde se atopan os métodos onCreate e onUpgrade).

Por exemplo:
  • Método: engadirAula(Aulas aula_engadir).
Engade unha aula á base de datos.
Leva como parámetro a aula a engadir.
1 	public long engadirAula(Aulas aula_engadir){
2 		ContentValues valores = new ContentValues();
3 		valores.put("nome", aula_engadir.getNome());
4 		long id = db.insert("AULAS",null,valores);
5 		
6 		return id;
7 	}
Como vemos devolve o id da aula engadida. O id é xerado automaticamente pola BD cando engadimos unha fila (lembrar que o ID é autonumérico e non se envía).
Nota:Poderíamos devolver un obxecto da clase Aula co novo id xa posto.


  • Método: ArrayList<Aulas> obterAulas().
Devolve as aulas da táboa AULAS.
A forma de devolver moitos obxectos dunha clase é utilizando un ArrayList.
 1 	public ArrayList<Aulas> obterAulas() {
 2 		ArrayList<Aulas> aulas_devolver = new ArrayList<Aulas>();
 3 
 4 		Cursor datosConsulta = sqlLiteDB.rawQuery(CONSULTAR_AULAS, null);
 5 		if (datosConsulta.moveToFirst()) {
 6 			Aulas aula;
 7 			while (!datosConsulta.isAfterLast()) {
 8 				aula = new Aulas(datosConsulta.getLong(0),
 9 						datosConsulta.getString(1));
10 				aulas_devolver.add(aula);
11 				datosConsulta.moveToNext();
12 			}
13 		}
14 		return aulas_devolver;
15 	}

Caso práctico

Neste exemplo imos copiar unha base de datos dende /assets/ ao cartafol .../databases/.

Dita BD consta dunha única táboa de nome AULAS cos seguintes campos:

  • _id: clave autonumérica.
  • nome: nome da aula.

A aplicación consta dunha lista (ListView) unha caixa de texto (EditText) e tres botóns para realizar operacións de Alta-Baixa-Modificación sobre as aulas.

Cabe sinalar que por motivos de tempo non están contempladas todas as condicións que teríamos que ter en conta para facer as operacións.

Así, por exemplo, cando damos de alta unha aula, non se comproba que tiñamos escrito algo na caixa de texto.

Preparación

  • Deberemos de ter no cartafol /assets/ a base de datos. Descomprimir o arquivo e copiar a base de datos a dito cartafol:

Media:PDM_UD1_06_BDEXEMPLO.zip

Creamos a activity

  • Nome do proxecto: UD1_06_DatosPersistentes_BD
  • Nome da activity: UD1_06_DatosPersistentes_BD.java


Código do layout xml

 1 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 2     xmlns:tools="http://schemas.android.com/tools"
 3     android:layout_width="match_parent"
 4     android:layout_height="match_parent"
 5     tools:context="${relativePackage}.${activityClass}" >
 6 
 7     <ListView
 8         android:id="@+id/UD1_06_lstAulas"
 9         android:layout_width="match_parent"
10         android:layout_height="200dp"
11         android:layout_alignParentTop="true"
12         android:layout_centerHorizontal="true"
13         android:background="@android:color/darker_gray"
14         android:choiceMode="singleChoice"
15         android:listSelector="#666666"
16         android:scrollbars="vertical"
17         android:scrollbarStyle="outsideOverlay"
18         />
19 
20 
21     <EditText
22         android:id="@+id/UD1_06_editNomeAula"
23         android:layout_width="match_parent"
24         android:layout_height="wrap_content"
25         android:layout_centerHorizontal="true"
26         android:layout_centerVertical="true"
27         android:inputType="text"
28         android:textSize="20sp"
29         />
30 
31     <Button
32         android:id="@+id/UD1_06_btnAltaAula"
33         android:layout_width="wrap_content"
34         android:layout_height="wrap_content"
35         android:width="150dp"
36         android:gravity="center_horizontal"
37         android:layout_alignParentBottom="true"
38         android:layout_alignParentLeft="true"
39         android:text="ALTA"
40         />
41 
42     <Button
43         android:id="@+id/UD1_06_btnModificarAula"
44         android:layout_width="wrap_content"
45         android:layout_height="wrap_content"
46         android:width="150dp"
47         android:gravity="center_horizontal"
48         android:layout_alignParentBottom="true"
49         android:layout_centerHorizontal="true"
50         android:text="MODIFICAR" />
51 
52     <Button
53         android:id="@+id/UD1_06_btnBaixaAula"
54         android:layout_width="wrap_content"
55         android:layout_height="wrap_content"
56         android:width="150dp"
57         android:gravity="center_horizontal"
58         android:layout_alignParentBottom="true"
59         android:layout_alignParentRight="true"
60         android:text="BAIXA" />
61 
62 </RelativeLayout>


Código da clase UD1_06_DatosPersistentes_BD
Obxectivo: Realizar operacións contra unha base de datos.

  1 import java.io.File;
  2 import java.io.FileOutputStream;
  3 import java.io.IOException;
  4 import java.io.InputStream;
  5 import java.io.OutputStream;
  6 import java.util.ArrayList;
  7 
  8 import android.app.Activity;
  9 import android.os.Bundle;
 10 import android.view.View;
 11 import android.view.View.OnClickListener;
 12 import android.widget.AdapterView;
 13 import android.widget.AdapterView.OnItemClickListener;
 14 import android.widget.ArrayAdapter;
 15 import android.widget.Button;
 16 import android.widget.EditText;
 17 import android.widget.ListView;
 18 import android.widget.Toast;
 19 #OLLO! Ao importar as clases seguintes
 20 import com......basedatos.Aulas;
 21 import com......basedatos.UD1_06_BASEDATOS;
 22 
 23 public class UD1_06_DatosPersistentes_BD extends Activity {
 24 	private UD1_06_BASEDATOS ud1_06_baseDatos;
 25 	private Aulas aula_seleccionada=null;	// Garda a aula seleccionada da lista
 26 
 27 	private void copiarBD() {
 28 		String bddestino = "/data/data/" + getPackageName() + "/databases/"
 29 				+ UD1_06_BASEDATOS.NOME_BD;
 30 		File file = new File(bddestino);
 31 		if (file.exists()) {
 32 			Toast.makeText(getApplicationContext(), "A BD NON SE VAI COPIAR. XA EXISTE", Toast.LENGTH_LONG).show();
 33 			return; // XA EXISTE A BASE DE DATOS
 34 		}
 35 
 36 		String pathbd = "/data/data/" + getPackageName()
 37 				+ "/databases/";
 38 		File filepathdb = new File(pathbd);
 39 		filepathdb.mkdirs();
 40 
 41 		InputStream inputstream;
 42 		try {
 43 			inputstream = getAssets().open(UD1_06_BASEDATOS.NOME_BD);
 44 			OutputStream outputstream = new FileOutputStream(bddestino);
 45 
 46 			int tamread;
 47 			byte[] buffer = new byte[2048];
 48 
 49 			while ((tamread = inputstream.read(buffer)) > 0) {
 50 				outputstream.write(buffer, 0, tamread);
 51 			}
 52 
 53 			inputstream.close();
 54 			outputstream.flush();
 55 			outputstream.close();
 56 			Toast.makeText(getApplicationContext(), "BASE DE DATOS COPIADA", Toast.LENGTH_LONG).show();
 57 		} catch (IOException e) {
 58 			// TODO Auto-generated catch block
 59 			e.printStackTrace();
 60 		}
 61 
 62 	}
 63 
 64 	private void xestionarEventos(){
 65 	
 66 		 Button btnAltaAula = (Button)findViewById(R.id.UD1_06_btnAltaAula);
 67 		 btnAltaAula.setOnClickListener(new OnClickListener() {
 68 		
 69 			@Override
 70 			public void onClick(View v) {
 71 				// TODO Auto-generated method stub
 72 				EditText editAula = (EditText) findViewById(R.id.UD1_06_editNomeAula);
 73 				// Habería que comprobar se hai algún dato na caixa de texto, pero neste exemplo centrámonos no funcionamento da base de datos.
 74 
 75 				Aulas aula = new Aulas(0, editAula.getText().toString());
 76 				long id = ud1_06_baseDatos.engadirAula(aula); // Obtemos o id. Neste exemplo non faremos nada con el.
 77 				aula.set_id(id);
 78 
 79 				// Poderíamos engadir a nova aula ó adaptador pero neste exemplo
 80 				// recargamos a lista
 81 				cargarLista();
 82 				editAula.setText("");
 83 
 84 				Toast.makeText(getApplicationContext(), "AULA ENGADIDA",Toast.LENGTH_LONG).show();
 85 			}
 86 		});
 87 		 
 88 		 Button btnBaixaAula = (Button)findViewById(R.id.UD1_06_btnBaixaAula);
 89 		 btnBaixaAula.setOnClickListener(new OnClickListener() {
 90 		
 91 			@Override
 92 			public void onClick(View v) {
 93 				// TODO Auto-generated method stub
 94 				
 95 				ud1_06_baseDatos.borrarAula(aula_seleccionada);
 96 				EditText editAula = (EditText)findViewById(R.id.UD1_06_editNomeAula);
 97 				editAula.setText("");
 98 				
 99 				// Poderíamos borrar a aula do adaptador e non cargar a lista novamente
100 				cargarLista();
101 				Toast.makeText(getApplicationContext(), "AULA BORRADA",Toast.LENGTH_LONG).show();
102 			}
103 		});
104 		 
105 		 Button btnModificaraAula = (Button)findViewById(R.id.UD1_06_btnModificarAula);
106 		 btnModificaraAula.setOnClickListener(new OnClickListener() {
107 		
108 			@Override
109 			public void onClick(View v) {
110 				// TODO Auto-generated method stub
111 				
112 				EditText editAula = (EditText)findViewById(R.id.UD1_06_editNomeAula);
113 				
114 				Aulas aula_modificar = new Aulas(aula_seleccionada.get_id(),editAula.getText().toString());
115 				ud1_06_baseDatos.modificarAula(aula_modificar);
116 				
117 				// Poderíamos borrar a aula do adaptador e non cargar a lista novamente
118 				cargarLista();
119 				Toast.makeText(getApplicationContext(), "AULA MODIFICADA",Toast.LENGTH_LONG).show();
120 			}
121 		});
122 		 
123 		 
124 
125 		ListView lista = (ListView)findViewById(R.id.UD1_06_lstAulas);
126 		lista.setOnItemClickListener(new OnItemClickListener() {
127 
128 			@Override
129 			public void onItemClick(AdapterView<?> arg0, View arg1, int arg2,
130 					long arg3) {
131 				// TODO Auto-generated method stub
132 				// Obtemos o obxecto aula seleccionado
133 				ArrayAdapter<Aulas> adaptador = (ArrayAdapter<Aulas>) arg0.getAdapter();
134 				aula_seleccionada = adaptador.getItem(arg2);
135 				EditText editAula = (EditText)findViewById(R.id.UD1_06_editNomeAula);
136 				editAula.setText(aula_seleccionada.getNome());
137 				
138 			}
139 		});
140 		
141 
142 		
143 		
144 	}
145 	
146 	/**
147 	 * Accede á base de datos para obter as aulas e as asina á lista.
148 	 */
149 	private void cargarLista(){
150 		
151 		ListView lista = (ListView)findViewById(R.id.UD1_06_lstAulas);
152 		
153 		ArrayList<Aulas> aulas = ud1_06_baseDatos.obterAulas();
154 		ArrayAdapter<Aulas> adaptador = new ArrayAdapter<Aulas>(getApplicationContext(), 
155 				android.R.layout.simple_list_item_1,aulas);
156 		lista.setAdapter(adaptador);
157 		
158 	}
159 	
160 	
161 	@Override
162 	public void onStart(){
163 		super.onStart();
164 		
165 		if (ud1_06_baseDatos==null) {	// Abrimos a base de datos para escritura
166 			ud1_06_baseDatos = new UD1_06_BASEDATOS(this);
167 			ud1_06_baseDatos.sqlLiteDB = ud1_06_baseDatos.getWritableDatabase();
168 
169 			cargarLista();
170 		}
171 	}
172 	
173 	@Override 
174 	public void onStop(){
175 		super.onStop();
176 		
177 		if (ud1_06_baseDatos!=null){	// Pechamos a base de datos.
178 			ud1_06_baseDatos.close();
179 			ud1_06_baseDatos=null;
180 		}
181 		
182 	}
183 	
184 	@Override
185 	protected void onCreate(Bundle savedInstanceState) {
186 		super.onCreate(savedInstanceState);
187 		setContentView(R.layout.activity_ud1_06__datos_persistentes__bd);
188 		
189 		copiarBD();
190 		xestionarEventos();
191 	}
192 }
  • Liñas 69-86: Xestionamos o evento Click sobre o botón de alta.
  • Liña 75: Creamos un obxecto da clase Aula co contido do EditText. O id non vai utilizarse xa que cando damos de alta o id non se utiliza.
  • Liña 76: Chamamos á base de datos có aula a dar de alta. Devolve o id (autonumérico).
  • Liña 81: Chamamos a o método que volve chamar á base de datos para cargar as aulas novamente.
  • Liñas 88-103: Xestionamos o evento Click sobre o botón de baixa.
  • Liña 95: Chamamos á base de datos para dar de baixa a aula seleccionada. Máis adiante está explicado que cando prememos sobre a lista gardamos en aula_seleccionada a aula seleccionada da lista.
  • Liña 100: Chamamos a o método que volve chamar á base de datos para cargar as aulas novamente.
  • Liñas 105-121: Xestionamos o evento Click sobre o botón de modificar.
  • Liña 114: Creamos o obxecto aula que vai a enviarse á base de datos. O id é o id da aula seleccionada na lista e o texto é o do EditText.
  • Liña 115: Chamamos á base de datos para modificar o nome da aula seleccionada.
  • Liña 118: Chamamos a o método que volve chamar á base de datos para cargar as aulas novamente.
  • Liñas 125-139: Xestionamos o evento Click sobre a lista.
  • Liña 134: Gardamos na propiedade 'aula_seleccionada' a aula seleccionada.
  • Liña 136: Cambiamos o texto do EditText polo seleccionado.
  • Liñas 149-158: Cargamos as aulas dende a base de datos á lista.
  • Liñas 165-170: Cando a aplicación empeza abrimos a base de datos e cargamos a lista coas aulas.
  • Liñas 177-180: Liberamos os recursos.

Creamos a clase que xestiona a base de datos

Nome da clase: UD1_06_BASEDATOS

Código da clase que xestiona a base de datos.

 1 import java.util.ArrayList;
 2 
 3 import android.content.ContentValues;
 4 import android.content.Context;
 5 import android.database.Cursor;
 6 import android.database.sqlite.SQLiteDatabase;
 7 import android.database.sqlite.SQLiteOpenHelper;
 8 
 9 public class UD1_06_BASEDATOS extends SQLiteOpenHelper{
10 
11 	public SQLiteDatabase sqlLiteDB;
12 
13 	public final static String NOME_BD="UD1_06_BDEXEMPLO";
14 	public final static int VERSION_BD=1;
15 	
16 	private final String CONSULTAR_AULAS ="SELECT _id,nome FROM AULAS order by nome";
17 	private final String TABOA_AULAS="AULAS";
18 
19 	
20 	public UD1_06_BASEDATOS(Context context) {
21 		super(context, NOME_BD, null, VERSION_BD);
22 		// TODO Auto-generated constructor stub
23 	}
24 
25 	@Override
26 	public void onCreate(SQLiteDatabase db) {
27 		// TODO Auto-generated method stub
28 		
29 	}
30 
31 	@Override
32 	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
33 		// TODO Auto-generated method stub
34 		
35 	}
36 	
37 	public long engadirAula(Aulas aula_engadir){
38 		ContentValues valores = new ContentValues();
39 		valores.put("nome", aula_engadir.getNome());
40 		long id = sqlLiteDB.insert("AULAS",null,valores);
41 		
42 		return id;
43 		
44 	}
45 	
46 	public int borrarAula(Aulas aula){
47 	    String condicionwhere = "_id=?";
48 	    String[] parametros = new String[]{String.valueOf(aula.get_id())};
49 	    int rexistrosafectados = sqlLiteDB.delete(TABOA_AULAS,condicionwhere,parametros);
50 	    
51 	    return rexistrosafectados;
52 	    
53 	}
54 	
55 	public int modificarAula(Aulas aula_modificar){
56 		ContentValues datos = new ContentValues();
57 		datos.put("nome", aula_modificar.getNome());
58 		
59 		String where = "_id=?";
60 		String[] params = new String[]{String.valueOf(aula_modificar.get_id())};
61 		
62 		int rexistrosModificados = sqlLiteDB.update(TABOA_AULAS, datos, where, params);
63 		
64 		return rexistrosModificados;
65 	}
66 	
67 
68 	public ArrayList<Aulas> obterAulas() {
69 		ArrayList<Aulas> aulas_devolver = new ArrayList<Aulas>();
70 
71 		Cursor datosConsulta = sqlLiteDB.rawQuery(CONSULTAR_AULAS, null);
72 		if (datosConsulta.moveToFirst()) {
73 			Aulas aula;
74 			while (!datosConsulta.isAfterLast()) {
75 				aula = new Aulas(datosConsulta.getLong(0),
76 						datosConsulta.getString(1));
77 				aulas_devolver.add(aula);
78 				datosConsulta.moveToNext();
79 			}
80 		}
81 
82 		return aulas_devolver;
83 	}	
84 
85 }








-- Ángel D. Fernández González e Carlos Carrión Álvarez -- (2014).