import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/**
 * To-many relationship, resolved on first access (and after reset).
 * Changes to to-many relations are not persisted, make changes to the target entity.
 */
@Generated(hash = 1773152342)
public List<Option> getOptionList() {
    if (optionList == null) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        OptionDao targetDao = daoSession.getOptionDao();
        List<Option> optionListNew = targetDao._queryQuestion_OptionList(id);
        synchronized (this) {
            if (optionList == null) {
                optionList = optionListNew;
            }
        }
    }
    return optionList;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/**
 * Builds a reusable query object for deletion (Query objects can be executed more efficiently than creating a
 * QueryBuilder for each execution.
 */
public DeleteQuery<T> buildDelete() {
    if (!joins.isEmpty()) {
        throw new DaoException("JOINs are not supported for DELETE queries");
    }
    String tablename = dao.getTablename();
    String baseSql = SqlUtils.createSqlDelete(tablename, null);
    StringBuilder builder = new StringBuilder(baseSql);

    // tablePrefix gets replaced by table name below. Don't use tableName here because it causes trouble when
    // table name ends with tablePrefix.
    appendJoinsAndWheres(builder, tablePrefix);

    String sql = builder.toString();
    // Remove table aliases, not supported for DELETE queries.
    // TODO(?): don't create table aliases in the first place.
    sql = sql.replace(tablePrefix + ".\"", '"' + tablename + "\".\"");
    checkLog(sql);

    return DeleteQuery.create(dao, sql, values.toArray());
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/** To-one relationship, resolved on first access. */
@Generated(hash = 1530824084)
public Measure getMeasure() {
    long __key = this.measure_id;
    if (measure__resolvedKey == null || !measure__resolvedKey.equals(__key)) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        MeasureDao targetDao = daoSession.getMeasureDao();
        Measure measureNew = targetDao.load(__key);
        synchronized (this) {
            measure = measureNew;
            measure__resolvedKey = __key;
        }
    }
    return measure;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/** Returns the count (number of results matching the query). Uses SELECT COUNT (*) sematics. */
public long count() {
    checkThread();
    Cursor cursor = dao.getDatabase().rawQuery(sql, parameters);
    try {
        if (!cursor.moveToNext()) {
            throw new DaoException("No result for count");
        } else if (!cursor.isLast()) {
            throw new DaoException("Unexpected row count: " + cursor.getCount());
        } else if (cursor.getColumnCount() != 1) {
            throw new DaoException("Unexpected column count: " + cursor.getColumnCount());
        }
        return cursor.getLong(0);
    } finally {
        cursor.close();
    }
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
private static Property[] reflectProperties(Class<? extends AbstractDao<?, ?>> daoClass)
        throws ClassNotFoundException, IllegalArgumentException, IllegalAccessException {
    Class<?> propertiesClass = Class.forName(daoClass.getName() + "$Properties");
    Field[] fields = propertiesClass.getDeclaredFields();

    ArrayList<Property> propertyList = new ArrayList<Property>();
    final int modifierMask = Modifier.STATIC | Modifier.PUBLIC;
    for (Field field : fields) {
        // There might be other fields introduced by some tools, just ignore them (see issue #28)
        if ((field.getModifiers() & modifierMask) == modifierMask) {
            Object fieldValue = field.get(null);
            if (fieldValue instanceof Property) {
                propertyList.add((Property) fieldValue);
            }
        }
    }

    Property[] properties = new Property[propertyList.size()];
    for (Property property : propertyList) {
        if (properties[property.ordinal] != null) {
            throw new DaoException("Duplicate property ordinals");
        }
        properties[property.ordinal] = property;
    }
    return properties;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/**
 * To-many relationship, resolved on first access (and after reset).
 * Changes to to-many relations are not persisted, make changes to the target entity.
 */
@Generated(hash = 1040074549)
public List<Grade> getGradeList() {
    if (gradeList == null) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        GradeDao targetDao = daoSession.getGradeDao();
        List<Grade> gradeListNew = targetDao._queryAccount_GradeList(id);
        synchronized (this) {
            if (gradeList == null) {
                gradeList = gradeListNew;
            }
        }
    }
    return gradeList;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/**
 * To-one relationship, resolved on first access.
 */
@Generated(hash = 1847191610)
public Location getLocation() {
    Long __key = this.locationID;
    if (location__resolvedKey == null || !location__resolvedKey.equals(__key)) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        LocationDao targetDao = daoSession.getLocationDao();
        Location locationNew = targetDao.load(__key);
        synchronized (this) {
            location = locationNew;
            location__resolvedKey = __key;
        }
    }
    return location;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/**
 * To-many relationship, resolved on first access (and after reset).
 * Changes to to-many relations are not persisted, make changes to the target entity.
 */
@Generated(hash = 1552857303)
public List<Lesson> getLessons() {
    if (lessons == null) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        LessonDao targetDao = daoSession.getLessonDao();
        List<Lesson> lessonsNew = targetDao._queryDay_Lessons(id);
        synchronized (this) {
            if (lessons == null) {
                lessons = lessonsNew;
            }
        }
    }
    return lessons;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/**
 * To-many relationship, resolved on first access (and after reset).
 * Changes to to-many relations are not persisted, make changes to the target entity.
 */
@Generated(hash = 1084217201)
public List<Order> getOrders() {
    if (orders == null) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        OrderDao targetDao = daoSession.getOrderDao();
        List<Order> ordersNew = targetDao._queryCustomer_Orders(id);
        synchronized (this) {
            if (orders == null) {
                orders = ordersNew;
            }
        }
    }
    return orders;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/** To-one relationship, resolved on first access. */
@Generated(hash = 752533316)
public CustomRules getRule() {
    long __key = this.rule_id;
    if (rule__resolvedKey == null || !rule__resolvedKey.equals(__key)) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        CustomRulesDao targetDao = daoSession.getCustomRulesDao();
        CustomRules ruleNew = targetDao.load(__key);
        synchronized (this) {
            rule = ruleNew;
            rule__resolvedKey = __key;
        }
    }
    return rule;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/**
 * To-many relationship, resolved on first access (and after reset).
 * Changes to to-many relations are not persisted, make changes to the target entity.
 */
@Generated(hash = 1620741698)
public List<GenreModel> getGenres() {
    if (genres == null) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        GenreModelDao targetDao = daoSession.getGenreModelDao();
        List<GenreModel> genresNew = targetDao._queryMovieOverviewModel_Genres(id);
        synchronized (this) {
            if (genres == null) {
                genres = genresNew;
            }
        }
    }
    return genres;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/**
 * To-many relationship, resolved on first access (and after reset).
 * Changes to to-many relations are not persisted, make changes to the target entity.
 */
@Generated(hash = 150995885)
public List<CastRelationModel> getCast() {
    if (cast == null) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        CastRelationModelDao targetDao = daoSession.getCastRelationModelDao();
        List<CastRelationModel> castNew = targetDao._queryMovieOverviewModel_Cast(id);
        synchronized (this) {
            if (cast == null) {
                cast = castNew;
            }
        }
    }
    return cast;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/**
 * To-many relationship, resolved on first access (and after reset).
 * Changes to to-many relations are not persisted, make changes to the target entity.
 */
@Generated(hash = 1914797064)
public List<CrewRelationModel> getCrew() {
    if (crew == null) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        CrewRelationModelDao targetDao = daoSession.getCrewRelationModelDao();
        List<CrewRelationModel> crewNew = targetDao._queryMovieOverviewModel_Crew(id);
        synchronized (this) {
            if (crew == null) {
                crew = crewNew;
            }
        }
    }
    return crew;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/**
 * To-many relationship, resolved on first access (and after reset).
 * Changes to to-many relations are not persisted, make changes to the target entity.
 */
@Generated(hash = 1800750450)
public List<Subject> getSubjectList() {
    if (subjectList == null) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        SubjectDao targetDao = daoSession.getSubjectDao();
        List<Subject> subjectListNew = targetDao._queryAccount_SubjectList(id);
        synchronized (this) {
            if (subjectList == null) {
                subjectList = subjectListNew;
            }
        }
    }
    return subjectList;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/** To-one relationship, resolved on first access. */
@Generated(hash = 1289461985)
public MovieOverviewModel getMovie() {
    long __key = this.movieId;
    if (movie__resolvedKey == null || !movie__resolvedKey.equals(__key)) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        MovieOverviewModelDao targetDao = daoSession.getMovieOverviewModelDao();
        MovieOverviewModel movieNew = targetDao.load(__key);
        synchronized (this) {
            movie = movieNew;
            movie__resolvedKey = __key;
        }
    }
    return movie;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/** To-one relationship, resolved on first access. */
@Generated(hash = 362483469)
public PersonModel getPerson() {
    Long __key = this.personId;
    if (person__resolvedKey == null || !person__resolvedKey.equals(__key)) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        PersonModelDao targetDao = daoSession.getPersonModelDao();
        PersonModel personNew = targetDao.load(__key);
        synchronized (this) {
            person = personNew;
            person__resolvedKey = __key;
        }
    }
    return person;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/** To-one relationship, resolved on first access. */
@Generated(hash = 625279819)
public AuthorBean getAuthor() {
    String __key = this.authorId;
    if (author__resolvedKey == null || author__resolvedKey != __key) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        AuthorBeanDao targetDao = daoSession.getAuthorBeanDao();
        AuthorBean authorNew = targetDao.load(__key);
        synchronized (this) {
            author = authorNew;
            author__resolvedKey = __key;
        }
    }
    return author;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/**
 * To-many relationship, resolved on first access (and after reset).
 * Changes to to-many relations are not persisted, make changes to the target entity.
 */
@Generated(hash = 34130431)
public List<VideoInfo> getVideoInfos() {
    if (videoInfos == null) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        VideoInfoDao targetDao = daoSession.getVideoInfoDao();
        List<VideoInfo> videoInfosNew = targetDao
                ._queryVideoFile_VideoInfos(fileID);
        synchronized (this) {
            if (videoInfos == null) {
                videoInfos = videoInfosNew;
            }
        }
    }
    return videoInfos;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/** To-one relationship, resolved on first access. */
@Generated(hash = 1574749097)
public ReviewBookBean getBook() {
    String __key = this.bookId;
    if (book__resolvedKey == null || book__resolvedKey != __key) {
        final DaoSession daoSession = this.daoSession;
        if (daoSession == null) {
            throw new DaoException("Entity is detached from DAO context");
        }
        ReviewBookBeanDao targetDao = daoSession.getReviewBookBeanDao();
        ReviewBookBean bookNew = targetDao.load(__key);
        synchronized (this) {
            book = bookNew;
            book__resolvedKey = __key;
        }
    }
    return book;
}
 

import org.greenrobot.greendao.DaoException; //导入依赖的package包/类
/**
 * Convenient call for {@link org.greenrobot.greendao.AbstractDao#update(Object)}.
 * Entity must attached to an entity context.
 */
@Generated(hash = 713229351)
public void update() {
    if (myDao == null) {
        throw new DaoException("Entity is detached from DAO context");
    }
    myDao.update(this);
}