Green dao
Upcoming SlideShare
Loading in...5
×
 

Green dao

on

  • 20,950 views

 

Statistics

Views

Total Views
20,950
Views on SlideShare
8,033
Embed Views
12,917

Actions

Likes
9
Downloads
99
Comments
1

18 Embeds 12,917

http://takiguchi0817.github.com 5418
http://blog.loadlimits.info 4351
http://takiguchi0817.github.io 2837
http://de.droidcon.com 162
http://localhost 81
http://blog.loadlimits.info.dev 19
http://webcache.googleusercontent.com 17
http://www.androidhelpline.in 10
https://twitter.com 7
http://translate.googleusercontent.com 5
http://www.codebean.in 3
http://takiguchi0817.github.io&_=1367400888936 HTTP 1
http://hatebutv.com 1
http://cache.yahoofs.jp 1
https://www.google.co.jp 1
http://www.google.co.jp 1
http://takiguchi0817.github.com&_=1363438680021 HTTP 1
http://hrt.happy.nu 1
More...

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Green dao Green dao Presentation Transcript

  • A look behind the scenes greenDAODroidcon Berlin 2012,Markus Junginger
  • About me, Follow me Android developer since 2007 Founder of greenrobot.de, Munich @green_dao Most updates  @greenrobot_de Most important updates  +Markus Junginger  +greenrobot 
  • Agenda What is greenDAO? – SQLite database – ORM – Code generation based on meta model Background info and „secret“ internals – Why code generation? – Performance Tweaks
  • Problem with DB Development Database world  ||  Java world No object orientation Data access feels quite low levely A lot of boilerplate code for SQLite – SQL scripts, e.g.: CREATE TABLE, Queries – Cursor iterations – Parameter binding
  • Common solution: ORM Java Object SQLite greenDAO Java Object Database Java Object ORM offers a higher level API – Read and write objects – CREATE TABLE done for you – Expressing Queries
  • Example: SQLite vs. greenDAOString[] columns = { "note", "date_changed" };String[] idArgs = { String.valueOf(id) };SQLiteCursor cursor = (SQLiteCursor) db.query("notes", columns,"_id=?", idArgs, null, null, "note");try { // greenDAO if (cursor.getCount() != 1) { Note note = noteDao.load(id); throw new Exception("Unexpected count: " +cursor.getCount()); updateUi(note.getNote(), note.getDate()); } cursor.moveToNext(); String note = cursor.getString(0); String date = cursor.getString(1); updateUi(note, date);} finally { cursor.close();}
  • greenDAO Overview Entities & DAOs Code generation Open Source: https://github.com/greenrobot/greenDAO Apache 2 license: core library (embedded in your app) GPL3: generator (you usually don‘t have changes here)
  • greenDAO StructureGenerator Project Android Project (Plain Java) Sources Schema-Model • Entities • Properties Generated • Relations Sources greenDAO Code Generation • Indexes, … • Entities • DAOs greenDAO Generator Lib greenDAO +FreeMarker Core Lib
  • Code Generation: Meta Model In generator project Defines data model (your schema) Define with Java
  • Example: Model for GeneratorSchema schema = new Schema(1, "de.greenrobot.daoexample");Entity simple = schema.addEntity("Note");simple.addIdProperty();simple.addStringProperty("text").notNull();simple.addDateProperty("date");new DaoGenerator().generateAll( "../DaoExample/src-gen", schema);
  • Example: Generated Entitypublic class Note { private String text; // ID, date and constructors skipped public String getText() { return text; } public void setText(String text) { this.text = text; }}
  • Code: Insert, Update, DeleteNote note = new Note();note.setText(“Say hello to world”);noteDao.insert(note);Log.d("Dao", “New ID: " + note.getId());note.setText(“Save the world”);noteDao.update(note);noteDao.delete(note);
  • QueryBuilder References generated Properties Java Complier checks Example: Get all users with first name “Joe“, and sort by last name List<User> joes = userDao.queryBuilder() .where(Properties.FirstName.eq("Joe")) .orderAsc(Properties.LastName) .list();
  • Entity relations Entity type relates to another entity type Supports to-one and to-many relations Unidirectional Bidirectional: requires manual updates
  • ToOne Example Entities Customer & Order An order has one customer Modelling in the generator project Property customerId = order.addLongProperty( "customerId").notNull().getProperty(); order.addToOne(customer, customerId); Resolving in the app Customer customer = order.getCostumer();
  • ToMany Example Entities Customer & Order A customer places many orders Modelling in the generator project Property customerId = order.addLongProperty( "customerId").notNull().getProperty(); customer.addToMany(order, customerId); Resolving in the app List<Order> orders = costumer.getOrderList();
  • Active Entities Have (some) persistence methods – update – delete – refresh
  • greenDAO Design Goals Maximum Performance Low resource usage – Memory consumption – Library size Easy-to-use API Focus on the essentials Optimized for Android
  • Save size, keep it the DRY way Generate code, but as sparly as possible Example: load method of DAO AbstractDao class (core library) – Implements everything expect readEntity Generated DAO implements readEntity – Just construct entities from a cursor position Library size: 59 KByte + some K per DAO
  • 3 Basic Performance Rules1. Group DB changes into a transaction! Can be like 500 times faster; still a FAQ2. Don’t forget database indexes3. Use prepared statements (precompiled)
  • Regular Performance Tracking Different scenarios are tested Tracked in Excel files Excel files are pushed to github
  • Why Code Generation? Annotation-based solutions: common with JEE ORMs (Hibernate, JPA) Parsing of annotations  start-up time Android & annotations: getting/setting values requires reflection Reflection quite slow on Android (n. slide) Code generation to avoid reflection
  • Reflection PerformanceMethod Reflection (roughly)getInt ~ 50 x slowergetString ~ 50 x slowersetInt ~ 400 x slowersetString ~ 150 x slower Example: 100,000 Operations (e.g. 10,000 entities with 10 properties) setInt: 9 ms, reflected 3875ms
  • Profiling to find hotspots Use traceview Enable in code: Debug. startMethodTracing( traceName); See class PerformanceTest
  • Reading entities & Constructor Entities read from the database Solution 1: Calling setters MyEntity myEntity = new MyEntity(); myEntity.setX(cursor.getString(0)); … Solution 2: Constructor only MyEntity myEntity = new MyEntity( cursor.getString(0), …); Performance gain: 33%
  • Optimization Candidate: Cursor Quite some time is spent in Android API android.database.AbstractWindowedCursor get… Methods are “slow” @Override public short getShort(int columnIndex) { checkPosition(); return mWindow.getShort(mPos, columnIndex); } @Override public int getInt(int columnIndex) { checkPosition(); return mWindow.getInt(mPos, columnIndex); }
  • Custom Cursor implementation Replacing SQLiteCursor de.greenrobot.dao.FastCursor Performance gain: ~30%
  • Lookup by ID Identity Scope (≈ Entity Caching) Mapping ID  Entity HashMap<Long, MyEntity> Problem: Long object creation LongSparseArray<MyEntity> Problem: does not scale Evaluated several alternatives
  • LongHashMap & More Custom de.greenrobot.dao.LongHashMap + Locking improvements + Minor performance tweaks Performance gain: from 30% up to 117%
  • Performance: Entities / SecondMeasured on a Nexus S (1 GHz), Android 2.3
  • Performance comparisonMeasured on a Nexus S (1 GHz), Android 2.3
  • Current Workflow vs. Migration Works best if you start from scratch (Start with Entity modeling) Migration: additional effort required – Pre-existing entities: have to be replaced – Existing tables: entities have to modeled Ideas how to address migration – Generic DAO (Annotation based entities!) – Import existing Model from SQLite DB files
  • Current Feature Requests Generate Adapters, CRUD Apps, Parceable, conversion to JSON/XML, … Convenience support for async ops Client/Server(Cloud) data synchronization More flexible primary keys (PKs) Pre- and post persist callbacks What is most important to you?
  • Disclaimer, Rechtliches Alle Inhalte urheberrechtlich geschützt. © Copyright 2011 Markus Junginger All rights reserved. Kontakt: markus@greenrobot.de http://greenrobot.de http://twitter.com/#!/greenrobot_de