Android-LazyDatabase

A fast way to store POJO in sqlite on an Android device without troubling yourself with database creation.

Deprecated

Google introduced Room which does the same thing, but better. I thereby deprecate Android-LazyDatabase, it's not useful anymore. It's still a good tutorial about how to upload artifacts to JCenter though.

What is it?

If you are working on a proof of concept app for Android (you should probably not use it for production in it's current state), and you need to store some good old POJO, this library is there for you. As the title says, it's a database for lazy people.

Warning

Seriously, don't use it for production, only for proof of concept or stuff like that. I mean, really, I might break everything with the next release. It's far from being future proof yet.

Usage

For Maven

<dependency>
    <groupId>net.redwarp.android.library</groupId>
    <artifactId>lazy-database</artifactId>
    <version>0.2.3</version>
    <type>aar</type>
</dependency>

For Gradle

compile 'net.redwarp.android.library:lazy-database:0.2.3'

How to?

Let's say you have a good old POJO class, like this:

public class GoodOldPojo {
  public String name;
  private int randomNumber;
  private float someValue;

  public GoodOldPojo(float someValue){
    this.someValue = someValue;
  }

  public float getSomeValue() {
    return someValue;
  }
}

First, modify it by setting a primary key, like that, and add an empty constructor:

import net.redwarp.library.database.annotation.PrimaryKey;

public class GoodOldPojo {
  @PrimaryKey
  public long key;
  public String name;
  private int randomNumber;
  private float someValue;

  public GoodOldPojo(){}

  (...)
}

You will then have to create a DatabaseHelper object, using a Context, that you will use to save and retrieve all your objects.

import net.redwarp.library.database.DatabaseHelper;

(...)

GoodOldPojo pojo = new GoodOldPojo(0.45f);
DatabaseHelper helper = new DatabaseHelper(context);

Saving

Saving is then straightforward:

helper.save(pojo);

It will create the database if it doesn't exist yet, and then save the object, and setting the long key to the inserted row value.

Saving in batch

helper.beginTransaction();
helper.save(pojo1);
helper.save(pojo2);
helper.save(pojo3);
helper.save(pojo4);
helper.setTransactionSuccessful();
helper.endTransaction();

Retrieving all data

List<GoodOldPojo> allPojos = helper.getAll(GoodOldPojo.class);

Retrieving one single POJO

GoodOldPojo retrievedPojo = helper.getWithId(GoodOldPojo.class, 2);

Object count

long count = helper.getCount(GoodOldPojo.class);

Chaining stuff

Let's say you have one POJO containing another POJO, like that:

public class GoodOldPojo {
  private OtherPojo object;
}

By default, it won't be saved. If you want it to be saved, you have to add the annotation @Chain to the field, like that:

public class GoodOldPojo {
  @Chain private OtherPojo otherPojo;
}

And voila, the otherPojo will be saved as well. By default, deleting the first one will also delete the second one. If you don't want the first item deletion to cascade on the second one, modify your class this way:

public class GoodOldPojo {
  @Chain(delete = false) private OtherPojo otherPojo;
}

What's left to do?

• A shit load
• Clear should also deleted chain elements
• Relations of type one to many
• Benchmarking (I mean, how fast is it compared to an hand written database)
• Search
• Unique keyword, etc...
• Nothing, it's deprecated