import ollie.query.Select; //导入依赖的package包/类
public static void testAddressItems(Context context) {
	Delete.from(SimpleAddressItem.class).execute();

	final Collection<SimpleAddressItem> ollieModels =
			Generator.getAddresses(SimpleAddressItem.class, MainActivity.LOOP_COUNT);

	long startTime = System.currentTimeMillis();
	// Reuse method so we don't have to write
	TransactionManager.transact(Ollie.getDatabase(), new Runnable() {
		@Override
		public void run() {
			Saver.saveAll(ollieModels);
		}
	});
	EventBus.getDefault().post(new LogTestDataEvent(startTime, FRAMEWORK_NAME, MainActivity.SAVE_TIME));

	startTime = System.currentTimeMillis();
	Collection<SimpleAddressItem> activeAndroidModelLoad =
			Select.from(SimpleAddressItem.class).fetch();
	EventBus.getDefault().post(new LogTestDataEvent(startTime, FRAMEWORK_NAME, MainActivity.LOAD_TIME));

	Delete.from(SimpleAddressItem.class).execute();
}
 

import ollie.query.Select; //导入依赖的package包/类
private List<String> getTagsNamesPerIds(@NonNull List<String> tagsIds) {
    boolean addSeparator = false;
    List<String> args = new ArrayList<>();

    StringBuilder whereStr = new StringBuilder("_id IN (");
    for (String tagId : tagsIds) {
        if (addSeparator) {
            whereStr.append(",");
        } else {
            addSeparator = true;
        }

        whereStr.append("?");
        args.add(tagId);
    }
    whereStr.append(")");

    List<Tag> tags = Select.from(Tag.class).where(whereStr.toString(), args.toArray(new String[args.size()])).fetch();
    List<String> tagsNames = new ArrayList<>(tags.size());
    for (Tag tag : tags) {
        tagsNames.add(tag.name);
    }
    return tagsNames;
}
 

import ollie.query.Select; //导入依赖的package包/类
@Override
public Collection<AddressItem> getAddresses() {
    if (addresses == null) {
        addresses = Select.from(AddressItem.class).where("addressBook = ?", id).fetch();
    }
    return addresses;
}
 

import ollie.query.Select; //导入依赖的package包/类
@Override
public Collection<Contact> getContacts() {
    if (contacts == null) {
        contacts = Select.from(Contact.class).where("addressBook = ?", id).fetch();
    }
    return contacts;
}
 

import ollie.query.Select; //导入依赖的package包/类
public static void testAddressBooks(Context context) {
	Delete.from(AddressItem.class).execute();
	Delete.from(Contact.class).execute();
	Delete.from(AddressBook.class).execute();

	Collection<AddressBook> addressBooks = Generator.createAddressBooks(AddressBook.class, Contact.class, AddressItem.class, MainActivity.ADDRESS_BOOK_COUNT);

	long startTime = System.currentTimeMillis();
	final Collection<AddressBook> finalAddressBooks = addressBooks;
	TransactionManager.transact(Ollie.getDatabase(), new Runnable()
	{
		@Override
		public void run()
		{
			Saver.saveAll(finalAddressBooks);
		}
	});
	EventBus.getDefault().post(new LogTestDataEvent(startTime, FRAMEWORK_NAME, MainActivity.SAVE_TIME));

	startTime = System.currentTimeMillis();
	addressBooks = Select.from(AddressBook.class).fetch();
	Loader.loadAllInnerData(addressBooks);
	EventBus.getDefault().post(new LogTestDataEvent(startTime, FRAMEWORK_NAME, MainActivity.LOAD_TIME));

	Delete.from(AddressItem.class).execute();
	Delete.from(Contact.class).execute();
	Delete.from(AddressBook.class).execute();
}
 

import ollie.query.Select; //导入依赖的package包/类
public List<Location> getLocations() {
    List<Location> locations = Select.from(Location.class).fetch();
    for (Location location : locations) {
        fillLocationData(location);
    }
    return locations;
}
 

import ollie.query.Select; //导入依赖的package包/类
private void fillBaggerData(@NonNull Bagger bagger, @NonNull List<String> tagsIds) {
    // contacts
    bagger.contacts = Select.from(Contact.class).where("contacts.bagger_id=?", bagger.id).fetchSingle();
    if (bagger.contacts == null) {
        bagger.contacts = new Contact();
    }

    // cities
    List<City> cities = Select.from(City.class).innerJoin(BaggerCity.class).on("cities._id=baggers_cities.city_id").where("baggers_cities.bagger_id=?", bagger.id).fetch();
    bagger.cities = new ArrayList<>();
    for (City city : cities) {
        bagger.cities.add(city.name);
    }

    // sessions
    List<Session> sessions = Select.from(Session.class).where("bagger_id=?", bagger.id).fetch();
    for (Session session : sessions) {
        List<Tag> tags = Select.from(Tag.class).innerJoin(SessionTag.class).on("tags._id=sessions_tags.tag_id").where("sessions_tags.session_id=?", session.id).fetch();
        session.tags = new ArrayList<>();
        for (Tag tag : tags) {
            session.tags.add(tag.name);
        }
    }
    bagger.sessions = filterSessionsMatchingTags(sessions, tagsIds);

    // websites
    bagger.websites = Select.from(Website.class).where("bagger_id=?", bagger.id).fetch();
}
 

import ollie.query.Select; //导入依赖的package包/类
@Override
public void loadVideos() {

    // Load the videos from the database
    Select.from(Video.class)
            .observable()
            .subscribe(new Action1<List<Video>>() {
                @Override
                public void call(List<Video> videos) {
                    mView.setVideos(videos);
                }
            });


}
 

import ollie.query.Select; //导入依赖的package包/类
public static List<Article> findAll() {
    return Select.from(Article.class).fetch();
}
 

import ollie.query.Select; //导入依赖的package包/类
public boolean hasData() {
    return Select.from(Location.class).fetchSingle() != null;
}
 

import ollie.query.Select; //导入依赖的package包/类
private void fillLocationData(@NonNull Location location) {
    location.audience = Select.from(Audience.class).where("audiences.location_id=?", location.id).fetchSingle();
    location.interests = Select.from(Interest.class).innerJoin(LocationInterest.class).on("interests._id=locations_interests.interest_id").where("locations_interests.location_id=?", location.id).fetch();
}
 

import ollie.query.Select; //导入依赖的package包/类
public boolean hasData() {
    return Select.from(City.class).fetchSingle() != null;
}
 

import ollie.query.Select; //导入依赖的package包/类
public List<City> getCities() {
    return Select.from(City.class).orderBy("name ASC").fetch();
}
 

import ollie.query.Select; //导入依赖的package包/类
public City getCityByLatLng(String lat, String lng) {
    return Select.from(City.class).where("lat=? AND lng=?", lat, lng).fetchSingle();
}
 

import ollie.query.Select; //导入依赖的package包/类
public boolean hasData() {
    return Select.from(Bagger.class).fetchSingle() != null;
}
 

import ollie.query.Select; //导入依赖的package包/类
/**
 * <p>
 * Find a record by id.
 * </p>
 *
 * @param cls The model class.
 * @param id  The model Id.
 * @return The query result.
 */
public static final <T extends Model> T find(Class<T> cls, Long id) {
	return Select.from(cls).where(_ID + "=?", id).fetchSingle();
}