查找

略
模糊查询：
SQL: SELECT FROM table WHERE column LIKE ‘%参数值%’;

Mybatis中模糊查询写法：
SELECT FROM table WHERE column LIKE ‘%${name}%’;
CONCAT()函数：进行字符串拼接
MySQL:CONCAT(参数1,参数2,……..)
Oracle:CONCAT(参数1,参数2)

MySQL:SELECT FROM table WHERE column LIKE CONCAT(‘%’,#{name},’%’);
Oracle:SELECT FROM table WHERE column LIKE ‘%’||#{name}||’%’;

插入,修改,删除

插入Sql使用的api是sqlSession.insert(“命名空间”,实体对象)
修改Sql使用的api是sqlSession.update(“命名空间”,实体对象)

插入和修改
useGeneratedKeys=””：默认情况下为false，设置为true，可以获取主键自动递增的值
keyProperty=””：将获取主键值，映射到对应属性
keyColumn=””:指定主键列名，如何主键列在表设计中是第一个，可省略
适用场景：刚插入数据，想要获得这条数据的主键

删除Sql使用的api是sqlSession.delete(“命名空间”,实体对象)
插入操作设计数据库数据变化，要使用sqlSession对象显示的提交事务
即

sqlSession.commit()

如果openSession(true) 开启true后 自动提交

一对一关系

实体类一对一的关系 在副的实体类中添加主的对象

public class Order {
    private int id;
    private String order_no;
    private int order_price;
    private User user;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getOrder_no() {
        return order_no;
    }
    public void setOrder_no(String order_no) {
        this.order_no = order_no;
    }
    public int getOrder_price() {
        return order_price;
    }
    public void setOrder_price(int order_price) {
        this.order_price = order_price;
    }
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
    @Override
    public String toString() {
        return "Order{" +
                "order_id=" + id +
                ", order_no='" + order_no + '\'' +
                ", order_price=" + order_price +
                ", user=" + user +
                '}';
    }
}

sql设置 resultMap 一对一使用 association 可以使用自动映射 auotmapping前提是 数据字段名和实体类名相同

  <resultMap id="orderMap" type="Order" autoMapping="true">
        <!--
            columnn 字段名称
            property 属性名称
        -->
        <id column="order_id" property="id"/>
        <association property="user" javaType="User" autoMapping="true">
            <id property="id" column="id"/>
        </association>
    </resultMap>
    <select id="findAll" resultMap="orderMap">
        select * from orders,users where  orders.order_uid=users.id
    </select>

一对多关系

一对多 在一的实体类中设置多的实体集合

public class User {
    private Integer id;
    private String name;
    private  Integer age;

    private Date birth;

    private List<Order> order;

    public List<Order> getOrder() {
        return order;
    }

    public void setOrder(List<Order> order) {
        this.order = order;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", birth=" + birth +
                ", order=" + order +
                '}';
    }
}

使用colection 代表集合 实现一对多

  <resultMap id="userMap" type="User" autoMapping="true">
        <id column="id" property="id"></id>
        <!--oftype集合中数据类型-->
        <collection property="order"  ofType="Order" autoMapping="true">
            <id property="id" column="order_id"/>
        </collection>

    </resultMap>

    <select id="findById" parameterType="Integer" resultMap="userMap">
      select * from users,orders where users.id =orders.order_uid
      <if test="id!=null">
          and users.id=#{id}
      </if>

    </select>

多对多关系

和一对多差不多 数据表建议一个中间表以另外两个表主键 为外键或主键 关联查询，各表与中间表就是一对多关系

联合查询

      Order findbyOId(Integer id);

      Order findbyOId2(Integer id);

 <resultMap id="Ordermap" type="Order" autoMapping="true">
        <id column="order_id" property="order_id"/>
        <association property="user"  javaType="User" autoMapping="true">
            <id column="id" property="id"/>
        </association>
    </resultMap>

    <select id="findbyOId2" parameterType="int" resultMap="Ordermap">
        select * from orders left join users on orders.order_uid=users.id where orders.order_id=#{id}
    </select>

嵌套查询

 <resultMap id="ordermap2" type="Order" autoMapping="true">
        <id column="order_id" property="order_id"/>
        <association property="user"  column="order_uid" select="findbyUId"/>
    </resultMap>

    <select id="findbyOId" parameterType="int"  resultMap="ordermap2">
     select * from orders where  orders.order_id =#{id}
    </select>

    <select id="findbyUId" parameterType="int" resultType="User">
        select * from  users where  users.id=#{id}
    </select>

嵌套查询有懒加载的一个机制，子查询可以在使用的时候加载，不使用就不加载
实现懒加载需要配置文件配置

全局配置：
            <!--true： 把所有级联查询都执行，3.4.1及之后的版本默认值为false，可不添加 -->
            <setting name="aggressiveLazyLoading" value="false" />
            <!-- 打开延迟加载 -->
            <setting name="lazyLoadingEnabled" value="true"/>

一般作用于association 和 collection

如果开启了全局加载可以在association 和 collection使用 fetchtype属性来局部指定懒加载
eager：关闭延迟加载
lazy：局部开启懒加载

  <association property="user"  javaType="User" autoMapping="true" fetchType="eager">