Lite Pal For Android - Free

  • LitePal for Android, LitePal for Android Library, Android Library
  • Description

  • change log

  • faq

  • Comments

  • LitePal for Android

    LitePal is an Open Source Android library that allows developers to use SQLite database extremely easy. You can finish most of the database operations without writing even a SQL statement, including create or upgrade tables, crud operations, aggregate functions, etc. The setup of LitePal is quite simple as well, you can integrate it into your project in less than 5 minutes.

    Experience the magic right now and have fun!

    Features

    • Using object-relational mapping (ORM) pattern.
    • Almost zero-configuration(only one configuration file with few properties).
    • Maintains all tables automatically(e.g. create, alter or drop tables).
    • Encapsulated APIs for avoiding writing SQL statements.
    • Awesome cluster query function.
    • Alternative choice to use SQL still, but easier and better APIs than the originals.
    • More for you to explore.
    (library contains *.class files and *.java files)

    Quick Setup

    1. Include library
    • Download the latest jar in the above section. Or browse all versions here to choose one to download.
    • Put the jar in the libs folder of your Android project.
    2. Configure litepal.xml

    Create a file in the assets folder of your project and name it as litepal.xml. Then copy the following codes into it.

    This is the only configuration file, and the properties are simple.

    • dbname configure the database name of project.
    • version configure the version of database. Each time you want to upgrade database, plus the value here.
    • list configure the mapping classes.
    3. Configure LitePalApplication

    You don't want to pass the Context param all the time. To makes the APIs simple, just configure the LitePalApplication in AndroidManifest.xml as below:

    Of course you may have your own Application and has already configured here, like:

    That's OK. LitePal can still live with that. Just change the inheritance of MyOwnApplication from Application to LitePalApplication, like:

    public class MyOwnApplication extends LitePalApplication {
        ...
    }
    

    This will make all things work without side effects.

    Get Started

    After setup, you can experience the powerful function now.

    1. Create tables

    Define the models first. For example you have two models, Album and Song. The models can be defined as below:

    public class Album extends DataSupport {
    
        private String name;
    
        private float price;
    
        private List songs = new ArrayList();
    
        // generated getters and setters.
        ...
    }
    public class Song extends DataSupport {
    
        private String name;
    
        private int duration;
    
        private Album album;
    
        // generated getters and setters.
        ...
    }
    

    Then add these models into the mapping list in litepal.xml:

    
        
        
    
    

    OK! The tables will be generated next time you operate database. For example, gets the SQLiteDatabase with following codes:

    SQLiteDatabase db = Connector.getDatabase();
    

    Now the tables will be generated automatically with SQLs like this:

    CREATE TABLE album (
        id integer primary key autoincrement,
        price real, 
        name text
    );
    
    CREATE TABLE song (
        id integer primary key autoincrement,
        duration integer, 
        name text, 
        album_id integer
    );
    
    2. Save data

    The saving API is quite object oriented. Each model which inherits from DataSupport would have the save() method directly.

    Album album = new Album();
    album.setName("album");
    album.setPrice(10.99f);
    album.save();
    Song song1 = new Song();
    song1.setName("song1");
    song1.setDuration(320);
    song1.setAlbum(album);
    song1.save();
    Song song2 = new Song();
    song2.setName("song2");;
    song2.setDuration(356);
    song2.setAlbum(album);
    song2.save();
    

    This will insert album, song1 and song2 into database with relations.

    3. Update data

    Each model which inherits from DataSupport would also have update() and updateAll() method. You can update a single record with a specified id:

     
    Album albumToUpdate = new Album();
    albumToUpdate.setPrice(20.99f); // raise the price
    albumToUpdate.update(id);
    

    Or you can update multiple records with a where condition:

    Album albumToUpdate = new Album();
    albumToUpdate.setPrice(20.99f); // raise the price
    albumToUpdate.updateAll("name = ?", "album");
    
    4. Delete data

    You can delete a single record using the static delete() method in DataSupport:

     
    DataSupport.delete(Song.class, id);
    

    Or delete multiple records using the static deleteAll() method in DataSupport:

     
    DataSupport.deleteAll(Song.class, "duration > ?" , "350");
    
    5. Query data

    Find a single record from song table with specified id:

     
    Song song = DataSupport.find(Song.class, id);
    

    Find all records from song table:

    List allSongs = DataSupport.findAll(Song.class);
    

    Constructing complex query with cluster query:

    List songs = DataSupport.where("name like ?", "song%").order("duration").find(Song.class);
    
    There is no Features content
  • There is no Related Products
  • There is no Change Log content
  • There is no FAQ