ALMACENAMIENTO EN ANDROID

Almacenamiento Interno y Externo

Son formas de almacenar archivos en un dispositivo Android. Cuando se requiere guardar datos, se puede hacer en un archivo de texto en el dispositivo, ya sea en el almacenamiento interno o externo.

SQLite

SQLite es una versión "minimizada" de SQL, lo que quiere decir que podremos tener bases de datos en Android pero no con todas las prestaciones de una base de datos normal de SQL.

Características de SQLite

• SQLite soporta múltiples tablas, índices, triggers y vistas.
• Lee y escribe directamente sobre archivos que se encuentran en el disco duro.
• El formato de la base de datos es multiplataforma y se puede utilizar el mismo archivo en un sistema de  32  y 64 bits.
• Utiliza el espacio en disco que es realmente necesario en cada momento ua que emplea registros de tamaño variable.
• SQL realiza operaciones de manera eficiente y es más rápido que MySQL y PostgreSQL.
• Cuenta con diversas interfaces API, lo que permite trabajar con C++, PHP, Python, Groovy, etc.
• Es totalmente auto contenida es decir que no tiene dependencias externas.
• Cuenta con librerías de acceso para muchos lenguajes de programación.
• Soporta funciones SQL definidas por el usuario (UDF).
• El código fuente es de dominio público y se encuentra muy bien documentado

• La base de datos completa se encuentra en un solo archivo.

• Puede funcionar enteramente en memoria, lo que la hace muy rápida.

• Tiene un footprint menor a 230KB.

• Es totalmente autocontenida (sin dependencias externas).

• Cuenta con librerías de acceso para muchos lenguajes de programación.

• Soporta texto en formato UTF-8 y UTF-16, así como datos numéricos de 64 bits.

• Soporta funciones SQL definidas por el usuario (UDF).

• El código fuente es de dominio público y se encuentra muy bien documentado.

Ventajas de SQLite

• No requiere configuración.
• No se requiere uso de servidor (proceso activo para atender la peticiones).
• Fácilmente portable (multiplataforma Windows, Linux, MAC, dispositivos móviles, Tablet, etc.) y posee un acceso mucho más rápido.

Desventajas de SQLite

• Posee deficiencias en la herramienta "where" esta limitación está dada por el soporte para clausuras anidadas. 
• De igual forma  es notoria  la falta de Claves Foráneas.

Ejemplo de Base de Datos SQLite con CRUD

private static final int DATABASE_VERSION = 1;

private static final String DATABASE_NAME = "contactsManager";

private static final String TABLE_NAME = "contacts";

private static final String KEY_ID = "id";
private static final String KEY_NAME = "name";
private static final String KEY_PH_NO = "phone_number";


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

@Overridepublic void onCreate(SQLiteDatabase db) {
    String CREATE_CONTACTS_TABLE = "CREATE TABLE " + TABLE_NAME + "("            + KEY_ID + " INTEGER PRIMARY KEY," + KEY_NAME + " TEXT,"            + KEY_PH_NO + " TEXT" + ")";
    db.execSQL(CREATE_CONTACTS_TABLE);
}

@Overridepublic void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
    db.execSQL("DROP TABLE IF EXISTS " + TABLE_NAME);
    onCreate(db);
}

public void addContact(Contact c) {
    SQLiteDatabase db = this.getWritableDatabase();

    ContentValues values = new ContentValues();
    values.put(KEY_NAME, c.getName());
    values.put(KEY_PH_NO, c.getPhoneNumber());

    db.insert(TABLE_NAME, null, values);
    db.close();

}

public Contact getContact(int id) {
    Contact cc = new Contact();
    SQLiteDatabase db = this.getWritableDatabase();

    Cursor cursor = db.query(TABLE_NAME, new String[] {KEY_ID, KEY_NAME, KEY_PH_NO}, KEY_ID + "=?", new String[] {String.valueOf(id)}, null, null, null, null);

    if (cursor != null) {
        cursor.moveToFirst();
        cc.setId(cursor.getInt(0));
        cc.setName(cursor.getString(1));
        cc.setPhoneNumber(cursor.getString(2));
    }

    return cc;

}

public List<Contact> getAllContacts() {
    List<Contact> contactList = new ArrayList<Contact>();

    String query = "SELECT * FROM " + TABLE_NAME;
    SQLiteDatabase db = this.getWritableDatabase();
    Cursor cursor = db.rawQuery(query, null);

    if (cursor.moveToFirst()) {
        do {
            Contact contact = new Contact();
            contact.setId(cursor.getInt(0));
            contact.setName(cursor.getString(1));
            contact.setPhoneNumber(cursor.getString(2));
            contactList.add(contact);
        } while (cursor.moveToNext());
    }

    return contactList;

}

public int getContactsCount() {
    String query = "SELECT * FROM " + TABLE_NAME;
    SQLiteDatabase db = this.getReadableDatabase();
    Cursor cursor = db.rawQuery(query, null);
    cursor.close();

    return cursor.getCount();
}

public void updateContact(Contact c) {

}

public void deleteContact(int id) {
    SQLiteDatabase db = this.getWritableDatabase();
    db.delete(TABLE_NAME, KEY_ID + " = ?",
            new String[] { String.valueOf(id) });
    db.close();
}