精华内容
参与话题
问答
  • ormlite

    2019-10-06 16:38:25
    id 主键 默认为falsegeneratedId 自增长的主键 默认值是falsegeneratedIdSequence 字符串名称的序列号 类同generatedId,但您可以指定序列的名称使用。默认为nullforeign 外键,默认为false,字段不能是一个原始类型...

    id 主键 默认为false

    generatedId 自增长的主键 默认值是false

    generatedIdSequence 字符串名称的序列号 类同generatedId,但您可以指定序列的名称使用。默认为null

    foreign 外键,默认为false,字段不能是一个原始类型。在外键对象的类中,必须要有一个ID字段(ID, generatedId,generatedIdSequence)

    useGetSet 应用get和set方法访问。默认为false

    unknownEnumName 表示该字段是一个Java的枚举类型

    throwIfNull 如果为空值,抛出一个异常 默认为false

    persisted 是否在数据库中存储这个领域 默认为true

    format 指定某一特定领域的信息格式,如指定日期字符串的格式

    unique 唯一约束,默认为false

    uniqueCombo 唯一行,该行内所有字段成为一个唯一约束,如有firstName 和 lastName两个字段,为"张"和"梅",那么该表内不可再插 入"张","梅", 但你可插入"张","全梅"。

    index 是否建立索引 默认为false

    uniqueIndex 唯一索引 默认为false

    indexName 为这一领域的索引添加一个名字

    uniqueIndexName 为这一领域的索引添加一个唯一的名字

    foreignAutoRefresh 当查询到一个外键对象时,是否自动刷新 如 Order表中有Account外键对象,当返回Order的记录时是否也返回Account的记录, 默认为false

    maxForeignAutoRefreshLevel 为了防止无限递归或者无限循环时 需要用到该属性设置自动刷新的最高级别

    allowGeneratedIdInsert 插入一个ID字段是否覆盖它生成的ID的对象 默认为false

    columnDefinition 定义列,默认情况下,数据库类型是用于自动生成所需的SQL来创建列,所以该属性并不常用

    foreignAutoCreate 在插入一个有外键对象的对象时,是否自动插入这个外键对象

    version 行版本 当一个对象被更新,以防止数据损坏多个实体时更新在同一时间进行的保护

    转载于:https://www.cnblogs.com/zahxz/p/4037933.html

    展开全文
  • OrmLite

    2018-04-24 09:04:31
    依赖: compile 'com.j256.ormlite:ormlite-android:5.0'model@DatabaseTable(tableName = CRM_DT_BAOGAO_FB4.TABLE_NAME) public class CRM_DT_BAOGAO_FB4 { public CRM_DT_BAOGAO_FB4() { } @Overr...


    • 依赖:

        compile 'com.j256.ormlite:ormlite-android:5.0'

    • model

    @DatabaseTable(tableName = CRM_DT_BAOGAO_FB4.TABLE_NAME)
    public class CRM_DT_BAOGAO_FB4 {
    
    
        public CRM_DT_BAOGAO_FB4() {
        }
    
        @Override
        public String toString() {
            return super.toString();
        }
    
        public static final String TABLE_NAME = "CRM_DT_BAOGAO_FB4";
    
    
    
        @DatabaseField(columnName = "JYJL_ID")
        private String JYJL_ID;
    
        @DatabaseField(columnName = "ATT1")
        private String ATT1;
    
    
    
        public String getJYJL_ID() {
            return JYJL_ID;
        }
    
        public void setJYJL_ID(String JYJL_ID) {
            this.JYJL_ID = JYJL_ID;
        }
    
        public String getATT1() {
            return ATT1;
        }
    
        public void setATT1(String ATT1) {
            this.ATT1 = ATT1;
        }
    }

    • DatabaseHelper 创建表
    @Override
        public void onCreate(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource) {
    
            Log.d("myorm", "表开始新建");
            try {
                
                TableUtils.createTable(connectionSource, CRM_DT_BAOGAO_FB1.class);  //附录
               
                Log.d("MyOrm", "表创建成功");
            } catch (SQLException e) {
                Log.d("MyOrm", "表创建失败");
                e.printStackTrace();
            }
        }


    • Dao
    public class CRM_DT_BAOGAO_FB4_Dao extends BaseDao<CRM_DT_BAOGAO_FB4,Integer> {
        public CRM_DT_BAOGAO_FB4_Dao(Context context) {
            super(context);
        }
    
        @Override
        public Dao<CRM_DT_BAOGAO_FB4, Integer> getDao() {
    
            try {
                return getHelper().getDao(CRM_DT_BAOGAO_FB4.class);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return null;
        }
    }
    public abstract class BaseDao<T, ID> {
    
        private DatabaseHelper helper;
    
        public BaseDao(Context context) {
            helper = DatabaseHelper.getInstance(context);
        }
    
        public DatabaseHelper getHelper() {
            return helper;
        }
    
        //两个泛型约束 一个是对应的实体类类型,一个是主键类型
        public abstract Dao<T, ID> getDao();
    
    
        //条件查询
        public List<T> queryForEq(String fieldName, Object value) {
    
            List<T> list = new ArrayList<>();
            try {
                list = getDao().queryForEq(fieldName, value);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return list;
        }
    
    
        public int add(T t) {
            try {
                return getDao().create(t);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return -1;
        }
    
        public int addList(List<T> list){
            try {
                return getDao().create(list);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return -1;
        }
    
        public List<T> getAll(){
            List<T> list = new ArrayList<>();
            try {
                list = getDao().queryForAll();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return list;
        }
    
    
        public T get(ID id){
            try {
                return getDao().queryForId(id);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        //会全部更新 方法很蠢 前提获取所有字段信息 遗弃不用
        public int update(T t){
            try {
                return getDao().update(t);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return -1;
        }
    
    
        //在DAO的函数不满足你的灵活性时,可能要用到原生更新语句,更新语句必须包含保留关键字 INSERT, DELETE,或者UPDATE,
        //(sql语句,参数)
        //String...  可变长度参数列表 new String[]{"",""}
        public int updateRaw(String statement,String... arguments) {
    
            try {
                return getDao().updateRaw(statement, arguments);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return -1;
        }
    
    
    
        //更新ID,其他值不变
        public int updateId(T t, ID id) {
            try {
                return getDao().updateId(t, id);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return -1;
        }
    
    
        /**
         * 删除该id的数据
         */
        public int delete(ID id){
            try {
                return getDao().deleteById(id);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return -1;
        }
    
    
        /**
         * 删除所有
         */
        public int deleteAll() {
    
            try {
                return getDao().deleteBuilder().delete();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return -1;
        }
    
    
    
    
    
    
    }

    • 操作数据表
    CRM_DT_BAOGAO_FB4_Dao dao4 = new CRM_DT_BAOGAO_FB4_Dao(getActivity());
            List<CRM_DT_BAOGAO_FB4> list4 = new ArrayList<>();
            list4 = dao4.queryForEq("JYJL_ID", ID);
            if (list4.size() != 0) {
                table.setATT1(list4.get(0).getATT1() == null ? "" : list4.get(0).getATT1());
    
            }

    展开全文
  • ORMLite

    2016-05-25 16:39:28
    Hongyang:http://blog.csdn.net/lmj623565791/article/details/39122981
    展开全文
  • There are more ways to query the database in ORMLite, so I'm planning to add more implementations, or maybe find a more generic way to cover all use-cases. <p>Please let me know if there's ...
  • <div><p>Hi, <p>I'm facing a database connection issue after configuration changes. I'm using a single activity which extends OrmLiteBaseActivity....j256/ormlite-android</p></div>
  • ormlite.rar

    2019-12-08 16:20:24
    在Android 中 ,可以使用 OrmLiteSqliteOpenHelper 作为数据库的辅助类, 可以说他就是已经封装好的SQLite数据库ormlite,在我的个人博客上也提到了,主要是方便阅读的同学们直接进行下载,方便进行学习
  • Ormlite基本使用

    千次阅读 2019-04-10 12:54:12
    首先需要导入ORMLite的依赖:在build.gradle中加入以下代码: implementation 'com.j256.ormlite:ormlite-android:5.1' implementation 'com.j256.ormlite:ormlite-core:5.1' 建立Bean类(以OneTableBean为例)...
    • 首先需要导入ORMLite的依赖:在build.gradle中加入以下代码:
     implementation 'com.j256.ormlite:ormlite-android:5.1'
     implementation 'com.j256.ormlite:ormlite-core:5.1'
    
    • 建立Bean类(以OneTableBean为例)
    import com.j256.ormlite.field.DatabaseField;
    import com.j256.ormlite.table.DatabaseTable;
    
    @DatabaseTable(tableName = "onetable")
    public class OneTableBean {
        @DatabaseField(generatedId = true, columnName = "messageId", unique = true)
        private int messageId;//主键
        @DatabaseField(columnName = "batchNo")
        private String batchNo;//批次号码	3
        @DatabaseField(columnName = "title")
        private String title;//标题	zzzz
        @DatabaseField(columnName = "content")
        private String content;//内容	zzz
    
        public int getMessageId() {
            return messageId;
        }
    
        public void setMessageId(int messageId) {
            this.messageId = messageId;
        }
    
        public String getBatchNo() {
            return batchNo;
        }
    
        public void setBatchNo(String batchNo) {
            this.batchNo = batchNo;
        }
    
        public String getTitle() {
            return title;
        }
    
        public void setTitle(String title) {
            this.title = title;
        }
    
        public String getContent() {
            return content;
        }
    
        public void setContent(String content) {
            this.content = content;
        }
    
        @Override
        public String toString() {
            return "OneTableBean{" +
                    "messageId=" + messageId +
                    ", batchNo='" + batchNo + '\'' +
                    ", title='" + title + '\'' +
                    ", content='" + content + '\'' +
                    '}';
        }
    }
    
    

    数据库中字段注解设置说明:

    在这里插入图片描述

    • 构建DatabaseHelper对DAO进行了统一的管理
    import android.annotation.SuppressLint;
    import android.content.Context;
    import android.database.sqlite.SQLiteDatabase;
    import android.util.ArrayMap;
    
    import com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper;
    import com.j256.ormlite.dao.Dao;
    import com.j256.ormlite.support.ConnectionSource;
    import com.j256.ormlite.table.TableUtils;
    
    import java.sql.SQLException;
    
    import cn.tsou.ormlite.bean.ArticleBean;
    import cn.tsou.ormlite.bean.OneTableBean;
    import cn.tsou.ormlite.bean.UserBean;
    
    /**
     * 数据库操作管理工具类
     * <p>
     * 我们需要自定义一个类继承自ORMlite给我们提供的OrmLiteSqliteOpenHelper,创建一个构造方法,重写两个方法onCreate()和onUpgrade()
     * 在onCreate()方法中使用TableUtils类中的createTable()方法初始化数据表
     * 在onUpgrade()方法中我们可以先删除所有表,然后调用onCreate()方法中的代码重新创建表
     * <p>
     * 我们需要对这个类进行单例,保证整个APP中只有一个SQLite Connection对象
     * <p>
     * 这个类通过一个Map集合来管理APP中所有的DAO,只有当第一次调用这个DAO类时才会创建这个对象(并存入Map集合中)
     * 其他时候都是直接根据实体类的路径从Map集合中取出DAO对象直接调用
     */
    public class DatabaseHelper extends OrmLiteSqliteOpenHelper {
        // 数据库名称
        public static final String DATABASE_NAME = "mydb.db";
    
        // 本类的单例实例
        private static DatabaseHelper instance;
    
        // 存储APP中所有的DAO对象的Map集合
        @SuppressLint("NewApi")
        private ArrayMap<String, Dao> daos = new ArrayMap<>();
    
        // 获取本类单例对象的方法
        public static synchronized DatabaseHelper getInstance(Context context) {
            if (instance == null) {
                synchronized (DatabaseHelper.class) {
                    if (instance == null) {
                        instance = new DatabaseHelper(context);
                    }
                }
            }
            return instance;
        }
    
        // 私有的构造方法
        private DatabaseHelper(Context context) {
            super(context, DATABASE_NAME, null, 1);
        }
    
        // 根据传入的DAO的路径获取到这个DAO的单例对象(要么从daos这个Map中获取,要么新创建一个并存入daos)
        public synchronized Dao getDao(Class clazz) throws SQLException {
            Dao dao = null;
            String className = clazz.getSimpleName();
            if (daos.containsKey(className)) {
                dao = daos.get(className);
            }
            if (dao == null) {
                dao = super.getDao(clazz);
                daos.put(className, dao);
            }
            return dao;
        }
    
        @Override // 创建数据库时调用的方法
        public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
            try {
                TableUtils.createTable(connectionSource, OneTableBean.class);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        @Override // 数据库版本更新时调用的方法
        public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
            try {
                TableUtils.dropTable(connectionSource, OneTableBean.class, true);
                onCreate(database, connectionSource);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        // 释放资源
        @Override
        public void close() {
            super.close();
            for (String key : daos.keySet()) {
                Dao dao = daos.get(key);
                dao = null;
            }
        }
    }
    

    注:新表建立必须在onCreate创建

    • 构建Bean对应的dao
    import android.content.Context;
    
    import com.j256.ormlite.dao.Dao;
    import com.j256.ormlite.stmt.QueryBuilder;
    
    import java.sql.SQLException;
    import java.util.List;
    
    import cn.tsou.ormlite.bean.OneTableBean;
    import cn.tsou.ormlite.manager.DatabaseHelper;
    
    /**
     * 操作OneTableBean数据表的Dao类,封装这操作OneTableBean表的所有操作
     * 通过DatabaseHelper类中的方法获取ORMLite内置的DAO类进行数据库中数据的操作
     * <p>
     * 调用dao的create()方法向表中添加数据
     * 调用dao的delete()方法删除表中的数据
     * 调用dao的update()方法修改表中的数据
     * 调用dao的queryForAll()方法查询表中的所有数据
     */
    public class OneTableDao {
        // ORMLite提供的DAO类对象,第一个泛型是要操作的数据表映射成的实体类;第二个泛型是这个实体类中ID的数据类型
        private Dao<OneTableBean, Integer> dao;
    
        public OneTableDao(Context context) {
            try {
                this.dao = DatabaseHelper.getInstance(context).getDao(OneTableBean.class);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 创建数据
         *
         * @param data
         */
        public void create(OneTableBean data) {
            try {
                dao.createOrUpdate(data);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 创建数据集合
         *
         * @param datas
         */
        public void createList(List<OneTableBean> datas) {
            try {
                dao.create(datas);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 向user表中添加一条数据
         * <p>
         * create:插入一条数据或集合
         * <p>
         * createIfNotExists:如果不存在则插入
         * <p>
         * createOrUpdate:如果指定id则更新
         *
         * @param data
         */
        public void insert(OneTableBean data) {
            try {
                dao.createIfNotExists(data);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        // 通过id删除指定数据
        public void delete(int id) {
            try {
                dao.deleteById(id);
            } catch (SQLException e) {
            }
        }
    
        // 删除表中的一条数据
        public void delete(OneTableBean data) {
            try {
                dao.delete(data);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        // 删除数据集合
        public void deleteList(List<OneTableBean> datas) {
            try {
                dao.delete(datas);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        //清空数据
        public void deleteAll() {
            try {
                dao.delete(dao.queryForAll());
            } catch (Exception e) {
            }
        }
    
        // 修改表中的一条数据
        public void update(OneTableBean data) {
            try {
                dao.update(data);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    
        // 查询表中的所有数据
        public List<OneTableBean> queryAll() {
            List<OneTableBean> users = null;
            try {
                users = dao.queryForAll();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return users;
        }
    
        // 根据ID取出用户信息
        public OneTableBean queryById(int id) {
            OneTableBean user = null;
            try {
                user = dao.queryForId(id);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return user;
        }
    
        // 通过条件查询集合(例如:通过messageId和title)
        public List<OneTableBean> queryByMessageIdAndTitle(int messageId, String title) {
            try {
                QueryBuilder<OneTableBean, Integer> builder = dao.queryBuilder();
                builder
                        .where()
                        .eq("messageId", messageId)
                        .and()
                        .eq("title", title);
                builder.orderBy("messageId", false);
                return builder.query();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        // 通过条件查询集合(例如:通过content)
        public List<OneTableBean> queryByContent(String content) {
            try {
                QueryBuilder<OneTableBean, Integer> builder = dao.queryBuilder();
                builder
                        .where()
                        .eq("content", content);
                builder.orderBy("title", false);
                return builder.query();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return null;
        }
    }
    
    • 测试
    import android.os.Bundle;
    import android.support.v7.app.AppCompatActivity;
    import android.util.Log;
    import android.view.View;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import cn.tsou.ormlite.bean.OneTableBean;
    import cn.tsou.ormlite.dao.OneTableDao;
    
    public class MainActivity extends AppCompatActivity {
    
        private int position;
        private OneTableDao oneTableDao;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            position = 0;
            oneTableDao = new OneTableDao(this);
        }
    
        /**
         * 创建数据集合
         *
         * @param view
         */
        public void createList(View view) {
            ArrayList<OneTableBean> oneTableBeans = new ArrayList<>();
            for (int i = 0; i < 10; i++) {
                OneTableBean oneTableBean = new OneTableBean();
                oneTableBean.setTitle("创建数据集合" + i);
                oneTableBean.setBatchNo("yes");
                oneTableBean.setContent("哎呀");
                oneTableBeans.add(oneTableBean);
            }
            oneTableDao.createList(oneTableBeans);
        }
    
    
        /**
         * 创建数据
         *
         * @param view
         */
        public void create(View view) {
            OneTableBean oneTableBean = new OneTableBean();
            oneTableBean.setTitle("huangxiaoguo" + position);
            oneTableBean.setBatchNo("yes");
            oneTableBean.setContent("大大");
            oneTableDao.create(oneTableBean);
    
            OneTableBean oneTableBean1 = new OneTableBean();
            oneTableBean1.setTitle("huangxiaoguo" + position);
            oneTableBean1.setBatchNo("大大");
            oneTableDao.create(oneTableBean1);
            position++;
        }
    
        /**
         * 添加一条数据
         *
         * @param view
         */
        public void add(View view) {
            OneTableBean oneTableBean = new OneTableBean();
            if (position == 6) {
                oneTableBean.setTitle("huangxiaoguo" + position);
                oneTableBean.setBatchNo("154546");
                oneTableBean.setContent("dadiouahddjaopdja");
            } else if (position == 8) {
                oneTableBean.setTitle("huangxiaoguo" + position);
            } else {
                oneTableBean.setTitle("huangxiaoguo" + position);
                oneTableBean.setBatchNo("no");
                oneTableBean.setContent("大大");
            }
            oneTableDao.insert(oneTableBean);
            position++;
        }
    
        /**
         * 通过id删除指定数据
         *
         * @param view
         */
        public void deleteByID(View view) {
            oneTableDao.delete(1);
        }
    
    
        /**
         * 删除user表中的一条数据
         *
         * @param view
         */
        public void delete(View view) {
            oneTableDao.delete(oneTableDao.queryById(2));
        }
    
        /**
         * 删除数据集合
         *
         * @param view
         */
        public void deleteList(View view) {
            oneTableDao.deleteList(oneTableDao.queryByContent("大大"));
        }
    
        /**
         * 清空数据
         *
         * @param view
         */
        public void deleteAll(View view) {
            oneTableDao.deleteAll();
        }
    
    
        /**
         * 更新
         *
         * @param view
         */
        public void updata(View view) {
            OneTableBean oneTableBean = oneTableDao.queryById(5);
            if (oneTableBean != null) {
                oneTableBean.setTitle("我被更新了");
                oneTableDao.update(oneTableBean);
            }
        }
    
    
        /**
         * 查询user表中的所有数据
         *
         * @param view
         */
        public void queryAll(View view) {
            Log.d("huangxiaoguo", "-----------------------------------------------");
            List<OneTableBean> oneTableBeans = oneTableDao.queryAll();
            for (int i = 0; i < oneTableBeans.size(); i++) {
                Log.d("huangxiaoguo", oneTableBeans.get(i).toString());
            }
    
        }
    
        /**
         * 根据ID取出用户信息
         *
         * @param view
         */
        public void queryById(View view) {
            OneTableBean oneTableBean = oneTableDao.queryById(5);
            Log.d("huangxiaoguo", "-----------------------------------------------");
            if (oneTableBean != null)
                Log.d("huangxiaoguo", oneTableBean.toString());
        }
    
        /**
         * 通过条件查询集合
         *
         * @param view
         */
        public void queryOther(View view) {
            List<OneTableBean> huangxiaoguo6 = oneTableDao.queryByMessageIdAndTitle(6, "huangxiaoguo0");
            Log.d("huangxiaoguo", "-----------------------------------------------");
            Log.d("huangxiaoguo", huangxiaoguo6.toString());
    
            List<OneTableBean> huangxiaoguo61 = oneTableDao.queryByContent("大大");
            Log.d("huangxiaoguo", "-----------------------------------------------");
            Log.d("huangxiaoguo", huangxiaoguo61.toString());
        }
    }
    
    
    • 效果展示
      在这里插入图片描述

    • Builder说明

         queryBuilder() 创建一个查询生成器:进行复杂查询
       
         deleteBuilder() 创建一个删除生成器,进程复杂条件删除
       
         updateBuilder() 创建修条件生成器,进行复杂条件修改
       
       条件查找器DeleteBuilder,QueryBuilder,UpdateBuilder  
      

    在SQL语句中,经常会用到where语句,where 进行条件筛选。
    dao.queryBuilder.()where()方法返回一个where对象,where中提供了很多方法来进行条件筛选,下边逐个讲where中的方法。

    方法 :eq(columnName,value) 等于(=)equals

    使用示范:mDao.queryBuilder().where().eq("id", 2).query();
    对应SQL:SELECT * FROM t_person WHERE id = 2
    

    方法 :lt(columnName,value) 小于(<) less than

    使用示范:mDao.queryBuilder().where().lt("id", 2).query();
    对应SQL:SELECT * FROM t_person WHERE id < 2
    

    方法 :gt(columnName,value) 大于(>) greater than

    使用示范:mDao.queryBuilder().where().gt("id", 2).query();
    对应SQL:SELECT * FROM t_person WHERE id > 2
    

    方法 :ge(columnName,value) 大于等于(>=)greater-than or equals-to

    使用示范:mDao.queryBuilder().where().ge("id", 2).query();
    对应SQL:SELECT * FROM t_person WHERE id >= 2
    

    方法 :le(columnName,value) 小于等于(<=)less than or equals-to

    使用示范:mDao.queryBuilder().where().le("id", 2).query();
    对应SQL:SELECT * FROM t_person WHERE id <= 2
    

    方法 :ne(columnName,value) 不等于(<>)not-equal-to

    使用示范:mDao.queryBuilder().where().ne("id", 2).query();
    对应SQL:SELECT * FROM t_person WHERE id <> 2
    

    方法 :in(columnName,object…) 在指定列中匹配object数组所对应的值,返回匹配到的结果行集合,in还有几个重载方法,需要的话可以去看文档或源码

    使用示范:mDao.queryBuilder().where().in("id", 1,2).query();
    对应SQL:SELECT * FROM t_person WHERE id IN (1,2 )
    

    方法 :notIn(columnName,object…) 在指定列中匹配object数组所对应的值,返回没有匹配到的结果行集合notIn还有几个重载方法,需要的话可以去看文档或源码

    使用示范:mDao.queryBuilder().where().notIn("id",1,2).query();
    对应SQL:SELECT * FROM t_person WHERE id NOT IN (1 ,2 )
    

    方法 :like(columnName,pattern) 使用%通配符来匹配,指定行数据,返回匹配到的结果

    使用示范:mDao.queryBuilder().where().like("LastName", "A%").query(); 匹配A开头的LastName
    mDao.queryBuilder().where().like("LastName", “%s").query(); 匹配s结尾的LastName
    mDao.queryBuilder().where().like("LastName", “%art%").query(); 匹配中间为art的LastName
    对应SQL:SELECT * FROM `t_person` WHERE `LastName` LIKE 'A%'
    

    方法 :between(columnName,low,high) 获取指定范围内的结果

    使用示范:mDao.queryBuilder().where().between("id", 1, 2).query();   获取id是1到2之间的结果
    对应SQL:SELECT * FROM `t_person` WHERE `id` BETWEEN 1 AND 2
    

    方法and(),or()用来组合上述where子语句。进行与,或操作。

    方法 :and() where子句与操作

    使用示范:mDao.queryBuilder().where().lt("id", 3).and().gt("id", 1).query();
    对应SQL:SELECT * FROM `t_person` WHERE (`id` < 3 AND `id` > 1 )
    

    方法 :or() where子句或操作

    使用示范:mDao.queryBuilder().where().eq("id", 1).or().eq("id", 2).query();
    对应SQL:SELECT * FROM `t_person` WHERE (`id` = 1 OR `id` = 2 )
    

    ORDER BY

    根据指定列名排序,降序,升序
    使用示范:mDao.queryBuilder().orderBy("id", false).query(); //参数false表示降序,true表示升序。
    对应SQL:SELECT * FROM `t_person` ORDER BY `id` DESC(降序)
    

    DISTINCT

    过滤指定列不重复数据行,重复的只返回一次。
    使用示范:mDao.queryBuilder().selectColumns("City").distinct().query();
    对应SQL:SELECT DISTINCT `City` FROM `t_person`
    

    GROUP BY

    按照指定列分组
    使用示范:mDao.queryBuilder().groupBy("city").query();
    对应SQL:SELECT * FROM t_person GROUP BY city
    

    offset Limit

    offset跳过指定的行数
    limit限制获取指定行数
    使用示范:mDao.queryBuilder().offset(2).limit(2).query();  可以用来分页
    对应SQL:SELECT * FROM t_person LIMIT 2 OFFSET 2
    

    Having

    等同于sql中的Having,针对分组数据,进行聚合函数(SUM, COUNT, MAX, AVG)运算。
    使用示范:mPersonList = mDao.queryBuilder().groupBy("City").having("SUM(id)>4").query()
    对应SQL:SELECT * FROM t_person GROUP BY City HAVING SUM(id)>4
    

    countOf

    返回查询结果的总数
    使用示范:mDao.queryBuilder().countOf()
    对应SQL:SELECT COUNT(*) FROM t_person
    

    iterator

    返回一个结果集的迭代器。
    使用示范:Iterator<Person> iterator = mDao.queryBuilder().iterator();
    

    queryForFirst

    返回所有行的第一行。
    使用示范:mDao.queryBuilder().queryForFirst();
    
    展开全文
  • androidstudio添加混淆后出了警告 都是ormlite 有大神知道怎么解决吗 ``` Warning:com.j256.ormlite.logger.Slf4jLoggingLog: can't find referenced class org.slf4j.LoggerFactory Warning:...
  • ORMlite数据库

    2019-10-11 20:52:24
    ORMlite基本使用依赖表类构造表具体实现 基本使用 依赖 implementation 'com.j256.ormlite:ormlite-android:5.0' implementation 'com.j256.ormlite:ormlite-core:5.0' 表类 @DatabaseTable(tableName = "t_user")...
  • ormlite事物

    2019-10-11 20:53:39
    Android工程搭建ormlite依赖 ormlite依赖 implementation 'com.j256.ormlite:ormlite-android:5.0' implementation 'com.j256.ormlite:ormlite-core:5.0' 具体代码 //缓存到本地数据库 val takeoutOpenHelper =...
  • ORMLite使用

    2019-10-11 21:01:38
    先去 ORMLite官网下载jar包 写博客时,目前最新的,对于Android为:ormlite-android-5.0.jar 和 ormlite-core-5.0.jar ; 首先要生成一个存放你各种属性的一个属性类,在类的开始添加注解 表明这是一张表,名字叫做...
  • android OrmLite

    2019-10-06 10:30:36
    最近在使用ormlite框架进行数据库的操作,下面简单的写个demo来学习下 1.下载jar包 这里使用的是ormlite-core-5.0.jar 和 ormlite-android-5.0.jar 将下载的jar包放到我们项目的libs文件夹下 2.创建实体类对象 ...
  • OrmLite简介

    2019-09-28 10:29:50
    pdf版本文档http://ormlite.com/docs/ormlite.pdf 使用步骤 1. 创建一个要保存到数据库的Java对象(使用注解标记), 查看Configuring a Class。 Setting Up Your Classes @Databas...
  • 本文主要介绍Android ormlite,这里提供实例代码并详细说明了 ormlite更改数据库默认位置,有需要的朋友可以参考下
  • 一个方便实用的OrmLite数据库框架,支持一键集成。 关于我 特征 支持通过@DataBase进行数据库配置。 支持自动生成数据库管理仓库DataBaseRepository。 支持内部存储和外部存储两种数据库。 支持自定义...
  • <div><p>http://ormlite.com/easy_java_orm.shtml Author had done support on such syntax Supports MySQL, Postgres, Microsoft SQL Server, H2, Derby, HSQLDB, and Sqlite and can be extended to additional ...
  • Android-ormlite-android.zip

    2019-09-17 12:46:41
    Android-ormlite-android.zip,Ormlite Android功能与Ormlite Core结合使用,安卓系统是谷歌在2008年设计和制造的。操作系统主要写在爪哇,C和C 的核心组件。它是在linux内核之上构建的,具有安全性优势。
  • Ormlite数据库

    2019-02-23 09:55:00
    1. Ormlite是什么? Android原生操作数据库的方式是这样的: 首先定义一个类继承SQLiteOpenHelper,重写onCreate和onUpdate 后续对数据库的增删改查以及创建和销毁都需要操作相对比较底层的sql语句,难以记忆又...
  • ormlite-sqlcipher android应用ormlite与sqlcipher结合的本地数据库,ormlit提供便利的数据库操作,sqlcipher对数据库进行加密。 sqlcipher源码参照https://github.com/wobuaihuangjun/android-database-sqlcipher
  • <div><p>i need to write the proguard configuration of ormlite. which classes or interfaces should be kept. can you show me the detail configuration of ormlite in the proguard-rules.txt.</p><p>该提问...
  • ormLite_jar

    2018-03-30 14:38:09
    OrmLite数据库框架,快捷便携操作数据库,适合Android快速开发
  • ormlite 笔记

    2018-07-02 14:18:23
    添加依赖:compile 'com.j256.ormlite:ormlite-android:5.0'使用常用注解:@DatabaseTable(tableName = "t_user") //指定实体和表的一一对应关系@DatabaseField() //指定属性和表中的列的一一对应关系常用...
  • ormlite 删除操作

    2019-10-06 14:14:12
    ormlite删除操作 DeleteBuilder<TransferDetailDtl, Integer> deleteBuilder = mRawDao.deleteBuilder(); deleteBuilder.where().eq(TransferDetailDtl.BILLNO, billNo).and().eq(TransferDetailDtl.ITEMCOD....
  • ormlite 批处理操作

    2019-10-06 14:13:57
    提高ormlite的批处理速度 http://stackoverflow.com/quegoogstions/11761472/ormlites-createorupdate-seems-slow-what-is-normal-speed This may be the "expected" speed unfortunately. Make sure you are us...
  • servicestack-ormlite

    2019-09-12 13:17:13
    建立数据库连接工厂 var dbfactory=new OrmLiteConnectionFactory(connstring,SqlServer2008OrmLiteDialectProvider.Instance); 此方法,只是建立连接工厂,并没有真正的建立连接 参数说明 第一个参数:连接字符串 ...

空空如也

1 2 3 4 5 ... 20
收藏数 1,578
精华内容 631
关键字:

ormlite