sql复制代码select * from sys_user u
LEFT JOIN sys_user_site s ON u.user_id = s.user_id
LEFT JOIN sys_dept d ON d.dept_id = s.dept_id
LEFT JOIN sys_emailinfo e ON u.user_id = e.userid AND e.MAIN_FLAG = 'Y'
<where>
 <include refid="userCondition"/>
</where>
limit #{offset}, #{limit}

bash复制代码<sql id="columns">
  id,title,content,original_img,is_user_edit,province_id,status,porder
</sql>

bash复制代码<select id="selectById" resultMap="RM_MsShortcutPanel">
 seelct
 <include refid="columns"/>
 from cms_self_panel
 where
 id = #{_parameter}
</select>

ini复制代码<resultMap id="BaseResultMap" type="com.unicom.portal.pcm.entity.ArticleEntity">
 <id column="id" jdbcType="BIGINT" property="id"/> 
 <collection property="paramList" column="id" select="queryparaminstancelist"/>
</resultMap>

csharp复制代码<select id="queryparaminstancelist" resultMap="ParamInstanceResultMap">
 select * from `cms_article_flow_param_instance` where article_id=#{id} 
</select>

ini复制代码<resultMap id="BaseResultMap" type="com.unicom.portal.pcm.entity.ArticleEntity">
 <association property="articleCount" javaType="com.unicom.portal.pcm.entity.MsArticleCount"/>
</resultMap>

perl复制代码<foreach collection="array" index="index" item="item" open="(" separator="," close=")">
 #{item}
</foreach>

csharp复制代码select r.*, (select d.org_name from sys_dept d where d.dept_id = r.dept_id) deptName from sys_role r
<where>
r.wid = #{wid}
<if test="roleName != null and roleName.trim() != ''">
and r.`role_name` like concat('%',#{roleName},'%')
</if>
<if test="status != null and status.trim() != ''">
and r.`status` = #{status}
</if>
</where>

vbnet复制代码<choose>
 <when test="sidx != null and sidx.trim() != ''">
 order by r.${sidx} ${order}
 </when>
 <otherwise>
 order by r.role_id asc
 </otherwise>
</choose>

bash复制代码SELECT id, grp_no grpNo, province_id provinceId, status FROM tj_group_province
<where> 
 ...
 <if test="_parameter!=null">
 and grp_no = #{_parameter}
 </if>
</where>

bash复制代码<update id="updateById">
 UPDATE cms_label
 <set>
   <if test="labelGroupId != null">
     label_group_id = #{labelGroupId},
   </if>
   dept_id = #{deptId},
   <if test="recommend != null">
     is_recommend = #{recommend},
   </if>
 </set>
 WHERE label_id = #{labelId} 
</update

ini复制代码LambdaQueryWrapper<UserEntity> lqw = Wrappers.lambdaQuery();
lqw.eq(UserEntity::getSex, 0L)
        .like(UserEntity::getUserName, "dun");
List<UserEntity> userList = userMapper.selectList(lqw);
userList.forEach(u -> System.out.println("like全包含关键字查询::" + u.getUserName()));

csharp复制代码@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

csharp复制代码new Thread(new Runnable() {
  @Override
  public void run() {
      System.out.println("xxxx");
  }
}).start();

scss复制代码 new Thread(()-> System.out.println("xxx")).start();

csharp复制代码@FunctionalInterface
public interface ISqlSegment extends Serializable {
    /**
     * SQL 片段
     */
    String getSqlSegment();
}

scss复制代码@Override
public Children in(boolean condition, R column, Collection<?> coll) {
    return doIt(condition, () -> columnToString(column), IN, inExpression(coll));
}

public Children notIn(boolean condition, R column, Collection<?> coll)

public Children inSql(boolean condition, R column, String inValue)

public Children notInSql(boolean condition, R column, String inValue)

public Children groupBy(boolean condition, R... columns)

public Children orderBy(boolean condition, boolean isAsc, R... columns)
    
public Children eq(boolean condition, R column, Object val)

public Children ne(boolean condition, R column, Object val)

public Children gt(boolean condition, R column, Object val)

public Children ge(boolean condition, R column, Object val)

public Children lt(boolean condition, R column, Object val)

public Children le(boolean condition, R column, Object val)

...

/**
 * 普通查询条件
 *
 * @param condition  是否执行
 * @param column     属性
 * @param sqlKeyword SQL 关键词
 * @param val        条件值
 */
protected Children addCondition(boolean condition, R column, SqlKeyword sqlKeyword, Object val) {
    return doIt(condition, () -> columnToString(column), sqlKeyword, () -> formatSql("{0}", val));
}

typescript复制代码/**
 * 对sql片段进行组装
 *
 * @param condition   是否执行
 * @param sqlSegments sql片段数组
 * @return children
 */
protected Children doIt(boolean condition, ISqlSegment... sqlSegments) {
    if (condition) {
        expression.add(sqlSegments);
    }
    return typedThis;
}
   
@FunctionalInterface
public interface ISqlSegment extends Serializable {

    /**
     * SQL 片段
     */
    String getSqlSegment();
}

scss复制代码sqlSegment = normal.getSqlSegment() + groupBy.getSqlSegment() + having.getSqlSegment() + orderBy.getSqlSegment()

java复制代码@Getter
@SuppressWarnings("serial")
public class MergeSegments implements ISqlSegment {

    private final NormalSegmentList normal = new NormalSegmentList();
    private final GroupBySegmentList groupBy = new GroupBySegmentList();
    private final HavingSegmentList having = new HavingSegmentList();
    private final OrderBySegmentList orderBy = new OrderBySegmentList();

    @Getter(AccessLevel.NONE)
    private String sqlSegment = StringPool.EMPTY;
    @Getter(AccessLevel.NONE)
    private boolean cacheSqlSegment = true;

    public void add(ISqlSegment... iSqlSegments) {
        List<ISqlSegment> list = Arrays.asList(iSqlSegments);
        ISqlSegment firstSqlSegment = list.get(0);
        if (MatchSegment.ORDER_BY.match(firstSqlSegment)) {
            orderBy.addAll(list);
        } else if (MatchSegment.GROUP_BY.match(firstSqlSegment)) {
            groupBy.addAll(list);
        } else if (MatchSegment.HAVING.match(firstSqlSegment)) {
            having.addAll(list);
        } else {
            normal.addAll(list);
        }
        cacheSqlSegment = false;
    }

    @Override
    public String getSqlSegment() {
        if (cacheSqlSegment) {
            return sqlSegment;
        }
        cacheSqlSegment = true;
        if (normal.isEmpty()) {
            if (!groupBy.isEmpty() || !orderBy.isEmpty()) {
                sqlSegment = groupBy.getSqlSegment() + having.getSqlSegment() + orderBy.getSqlSegment();
            }
        } else {
            sqlSegment = normal.getSqlSegment() + groupBy.getSqlSegment() + having.getSqlSegment() + orderBy.getSqlSegment();
        }
        return sqlSegment;
    }
}

xml复制代码<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
  <groupId>com.github.pagehelper</groupId>
  <artifactId>pagehelper-spring-boot-starter</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>mybatis-plus-boot-starter</artifactId>
</dependency>
<dependency>
  <groupId>org.projectlombok</groupId>
  <artifactId>lombok</artifactId>
</dependency>
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-test</artifactId>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <scope>test</scope>
</dependency>
<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-lang3</artifactId>
</dependency>
<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
</dependency>

less复制代码@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PACKAGE)
@SuperBuilder(toBuilder = true)
@Data
public class BaseEntity {

    @TableField(value = "created_tm", fill = FieldFill.INSERT)
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime createdTm;

    @TableField(value = "created_by", fill = FieldFill.INSERT)
    private String createdBy;

    @TableField(value = "modified_tm", fill = FieldFill.INSERT_UPDATE)
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private LocalDateTime modifiedTm;

    @TableField(value = "modified_by", fill = FieldFill.INSERT_UPDATE)
    private String modifiedBy;
}

less复制代码@EqualsAndHashCode(callSuper = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PACKAGE)
@SuperBuilder(toBuilder = true)
@Data
@TableName("sys_user")
public class UserEntity extends BaseEntity{
    private Long userId;
    private String userName;
    private Integer sex;
    private Integer age;
    private String mobile;
}

less复制代码List<UserDTO> selectUsers();

UserEntity selectByIdOnXml(long userId);

@Results(id = "userResult", value = {
        @Result(property = "user_id", column = "userId", id = true),
        @Result(property = "userName", column = "user_name"),
        @Result(property = "sex", column = "sex"),
        @Result(property = "mobile", column = "mobile"),
        @Result(property = "age", column = "age")
})
@Select("select * from sys_user where user_id = #{id}")
UserEntity selectByIdOnSelectAnnotation(@Param("id") long id);

@SelectProvider(type = UserSqlProvider.class, method = "selectById")
@ResultMap("BaseResultMap")
UserEntity selectByIdOnSelectProviderAnnotation(long id);

@Select("select * from sys_user where user_id = #{id} and user_name=#{userName}")
@ResultMap("BaseResultMap")
UserEntity selectByIdOnParamAnnotation(@Param("id") long id, @Param("userName") String uerName);

ini复制代码<mapper namespace="com.dunzung.mybatisplus.query.mapper.UserMapper">
    <resultMap id="BaseResultMap" type="com.dunzung.mybatisplus.query.entity.UserEntity">
        <id column="user_id" property="userId"/>
        <result column="user_name" property="userName"/>
        <result column="sex" property="sex"/>
        <result column="age" property="age"/>
        <result column="mobile" property="mobile"/>
    </resultMap>
    
    <resultMap id="RelationResultMap" type="com.dunzung.mybatisplus.query.entity.UserDTO" extends="BaseResultMap">
        <association property="card" column="{userId,user_id}"
                     select="com.dunzung.mybatisplus.query.mapper.CardMapper.selectCardByUserId"/>
        <collection property="orders" column="{userId,user_id}"
                    select="com.dunzung.mybatisplus.query.mapper.OrderMapper.selectOrders"/>
    </resultMap>
    
    <select id="selectUsers" resultMap="RelationResultMap">
        select * from sys_user
    </select>
    
    <select id="selectByIdOnXml" resultMap="BaseResultMap">
        select * from sys_user where user_id = #{userId}
   </select>
    
</mapper>

kotlin复制代码@Data
@TableName("sys_user_card")
public class CardEntity {
    private Long cardId;
    private String cardCode;
    private Long userId;
}

java复制代码@Mapper
public interface OrderMapper extends BaseMapper<OrderEntity> {
}

ini复制代码<mapper namespace="com.dunzung.mybatisplus.query.mapper.OrderMapper">
    <resultMap id="BaseResultMap" type="com.dunzung.mybatisplus.query.entity.OrderEntity">
        <id column="order_id" property="orderId"/>
        <result column="order_name" property="orderName"/>
        <result column="user_id" property="userId"/>
        <result column="price" property="price"/>
        <result column="created_tm" property="createdTm"/>
    </resultMap>

    <select id="selectOrders" resultMap="BaseResultMap">
         select * from biz_order where user_id = #{userId}
    </select>

</mapper>

kotlin复制代码@Data
@TableName("biz_order")
public class OrderEntity {
    private Long orderId;
    private String orderName;
    private Integer userId;
    private Date createdTm;
    private Integer price;
}

java复制代码@Mapper
public interface CardMapper extends BaseMapper<CardEntity> {
}

ini复制代码<mapper namespace="com.dunzung.mybatisplus.query.mapper.CardMapper">
    <resultMap id="BaseResultMap" type="com.dunzung.mybatisplus.query.entity.CardEntity">
        <id column="card_id" property="cardId"/>
        <result column="card_code" property="cardCode"/>
        <result column="user_id" property="userId"/>
    </resultMap>
    <select id="selectCardByUserId" resultMap="BaseResultMap">
        select * from sys_user_card where user_id = #{userId}
    </select>
</mapper>

ini复制代码LambdaQueryWrapper<UserEntity> lambda = new QueryWrapper<UserEntity>().lambda();

ini复制代码LambdaQueryWrapper<UserEntity> lambda = new  LambdaQueryWrapper<>();

ini复制代码LambdaQueryWrapper<UserEntity> lambda = Wrappers.lambdaQuery();

sql复制代码List<UserEntity> users = new LambdaQueryChainWrapper<UserEntity>(userMapper)
            .like(User::getName, "雨").ge(User::getAge, 20).list();

yaml复制代码#mybatis
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

perl复制代码@Test
public void testLambdaQueryOfEq() {
    //eq查询
    //相当于 select * from sys_user where user_id = 1
    LambdaQueryWrapper<UserEntity> lqw = Wrappers.lambdaQuery();
    lqw.eq(UserEntity::getUserId, 1L);
    UserEntity user = userMapper.selectOne(lqw);
    System.out.println("eq查询::" + user.getUserName());
}

csharp复制代码select * from sys_user where user_id = 1

ini复制代码@Test
public void testLambdaQueryOfIn() {  
    List<Long> ids = Arrays.asList(1L, 2L);
    LambdaQueryWrapper<UserEntity> lqw = Wrappers.lambdaQuery();  
    lqw.in(UserEntity::getUserId, ids);
    List<UserEntity> userList = userMapper.selectList(lqw);
    userList.forEach(u -> System.out.println("in查询::" + u.getUserName()));
}

csharp复制代码select * from sys_user where user_id in (1,2)

ini复制代码@Test
public void testLambdaQueryOfLikeAll() {
    LambdaQueryWrapper<UserEntity> lqw = Wrappers.lambdaQuery();
    lqw.eq(UserEntity::getSex, 0L)
            .like(UserEntity::getUserName, "dun");
    List<UserEntity> userList = userMapper.selectList(lqw);
    userList.forEach(u -> System.out.println("like全包含关键字查询::" + u.getUserName()));
}

sql复制代码select * from sys_user where sex = 0 and user_name like '%dun%'

ini复制代码@Test
public void testLambdaQueryOfLikeRight() { 
    LambdaQueryWrapper<UserEntity> lqw = Wrappers.lambdaQuery();
    lqw.eq(UserEntity::getSex, 0L)
            .likeRight(UserEntity::getUserName, "dun");
    List<UserEntity> userList = userMapper.selectList(lqw);
    userList.forEach(u -> System.out.println("like Right含关键字查询::" + u.getUserName()));
}

sql复制代码select * from sys_user where sex = 0 and user_name like 'dun%'

ini复制代码@Test
public void testLambdaQueryOfLikeLeft() {  
    LambdaQueryWrapper<UserEntity> lqw = Wrappers.lambdaQuery();
    lqw.eq(UserEntity::getSex, 0L)
            .likeLeft(UserEntity::getUserName, "zung");
    List<UserEntity> userList = userMapper.selectList(lqw);
    userList.forEach(u -> System.out.println("like Left含关键字查询::" + u.getUserName()));
}

sql复制代码select * from sys_user where sex = 0 and user_name like '%zung'

scss复制代码@Test
public void testLambdaQueryOfBoolCondition() {
    UserEntity condition = UserEntity.builder()
            .sex(1)
            .build();
    //eq 或 like 条件判断查询
    LambdaQueryWrapper<UserEntity> lqw = Wrappers.lambdaQuery();
    lqw.eq(condition.getSex() != null, UserEntity::getSex, 0L)
            // 满足 bool 判断，是否进查询按字段 userName 查询
            .like(condition.getUserName() != null, UserEntity::getUserName, "dun");
    List<UserEntity> userList = userMapper.selectList(lqw);
    userList.forEach(u -> System.out.println("like查询::" + u.getUserName()));
}

less复制代码@Test
public void testLambdaQueryOfOr_And() {  
    LambdaQueryWrapper<UserEntity> lqw = Wrappers.lambdaQuery();
    lqw.eq(UserEntity::getSex, 0L)
            .and(wrapper->wrapper.eq(UserEntity::getUserName,"dunzung")
                    .or().ge(UserEntity::getAge, 50));
    List<UserEntity> userList = userMapper.selectList(lqw);
    userList.forEach(u -> System.out.println("like查询::" + u.getUserName()));
}

csharp复制代码select * from sys_user where sex = 0 and (use_name = 'dunzung' or age >=50)

ini复制代码@Test
public void testLambdaPage() {
    //PageHelper分页查询
    //相当于 select * from sys_user limit 0,2
    int pageNumber = 0;
    int pageSize = 2;
    PageHelper.startPage(pageNumber + 1, pageSize);
    LambdaQueryWrapper<UserEntity> lqw = Wrappers.lambdaQuery();
    lqw.orderByAsc(UserEntity::getAge)
          .orderByDesc(UserEntity::getMobile);
    List<UserEntity> userList = userMapper.selectList(lqw); 
    userList.forEach(u -> System.out.println("page分页查询::" + u.getUserName()));
}

sql复制代码select * from sys_user order by age desc,mobile desc limit 0,2

less复制代码IPage<T> selectPage(IPage<T> page, @Param("ew") Wrapper<T> queryWrapper);
IPage<Map<String, Object>> selectMapsPage(IPage<T> page, @Param("ew") Wrapper<T> queryWrapper);

typescript复制代码@Bean
public PaginationInterceptor paginationInterceptor() {
    return new PaginationInterceptor();
}

csharp复制代码@Test
public void testLambdaUpdate() {
    LambdaUpdateWrapper<UserEntity> luw = Wrappers.lambdaUpdate();
    luw.set(UserEntity::getUserName, "dunzung01")
            .set(UserEntity::getSex, 1);
    luw.eq(UserEntity::getUserId, 1);
    userMapper.update(null, luw);
}

csharp复制代码@Test
public void testOnAssociationTag() {
    List<UserDTO> userList = userMapper.selectUsers();
    userList.forEach(u -> System.out.println(u.getUserName()));
}

ini复制代码<resultMap id="RelationResultMap" type="com.dunzung.mybatisplus.query.entity.UserDTO" extends="BaseResultMap">
  <association property="card" column="{userId,user_id}"
               select="com.dunzung.mybatisplus.query.mapper.CardMapper.selectCardByUserId"/>
</resultMap>

csharp复制代码@Test
public void testOnCollectionTag() {
    List<UserDTO> userList = userMapper.selectUsers();
    userList.forEach(u -> System.out.println(u.getUserName()));
}

ini复制代码<resultMap id="RelationResultMap" type="com.dunzung.mybatisplus.query.entity.UserDTO" extends="BaseResultMap">
  <collection property="orders" 
      column="{userId,user_id}" 
      select="com.dunzung.mybatisplus.query.mapper.OrderMapper.selectOrders"/>
  </resultMap>

ini复制代码 <resultMap id="RelationResultMap" type="com.dunzung.mybatisplus.query.entity.UserDTO" extends="BaseResultMap">
        <association property="card" column="{userId,user_id}"
                     select="com.dunzung.mybatisplus.query.mapper.CardMapper.selectCardByUserId"/>
        <collection property="orders" column="{userId,user_id}"
                    select="com.dunzung.mybatisplus.query.mapper.OrderMapper.selectOrders"/>
    </resultMap>

less复制代码@TableField(value = "created_tm", fill = FieldFill.INSERT)
private LocalDateTime createdTm;

@TableField(value = "modified_tm", fill = FieldFill.INSERT_UPDATE)
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime modifiedTm;

kotlin复制代码/**
 * 属性值填充 Handler
 *
 * @author 猿芯
 * @since 2021/3/30
 */
@Component
public class FillMetaObjectHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
        this.setInsertFieldValByName("createdTm", LocalDateTime.now(), metaObject);
        this.setInsertFieldValByName("createdBy", MvcContextHolder.getUserName(), metaObject);
        this.setFieldValByName("modifiedTm", LocalDateTime.now(), metaObject);
        this.setFieldValByName("modifiedBy", MvcContextHolder.getUserName(), metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
        this.setUpdateFieldValByName("modifiedTm", LocalDateTime.now(), metaObject);
        this.setUpdateFieldValByName("modifiedBy", MvcContextHolder.getUserName(), metaObject);
    }
}

less复制代码@Select("select * from mysql_data ${ew.customSqlSegment}")
List<MysqlData> getAll(@Param(Constants.WRAPPER) Wrapper wrapper);

sql复制代码List<MysqlData> getAll(Wrapper ew);
<select id="getAll" resultType="MysqlData">
 SELECT * FROM mysql_data ${ew.customSqlSegment}
</select>

arduino复制代码public static final int SERVICE_ARGS = 115;
public static final int STOP_SERVICE = 116;
public static final int PAUSE_ACTIVITY = 101;
public static final int STOP_ACTIVITY_SHOW = 103;
public static final int SLEEPING  = 137;

java复制代码private final void addCount(long x, int check) {
        // 借用Longadder的设计思路来统计map的当前容量，减少锁竞争，详细见下面的分析
        CounterCell[] as; long b, s;
        if ((as = counterCells) != null ||
            !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
            CounterCell a; long v; int m;
            boolean uncontended = true;
            if (as == null || (m = as.length - 1) < 0 ||
                (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
                !(uncontended =
                  U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
                fullAddCount(x, uncontended);
                return;
            }
            if (check <= 1)
                return;
            s = sumCount();
        }
        if (check >= 0) {
            Node<K,V>[] tab, nt; int n, sc;
            // s是当前的容量，sizeCtl是扩容阈值，当当前容量大于扩容阈值时，触发扩容，在扩容逻辑被触发前sizeCtl是正数，表示的下次触发扩容的阈值，
            // 而在进入扩容逻辑后，sizeCtl会变成负数，并且sizeCtl是32位的int类型，高16位是扩容的邮戳，低16位是同时进行扩容时的线程数，在某个线程进入扩容时会修改sizeCtl值，在下面的代码里能看到这个修改逻辑
            while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
                   (n = tab.length) < MAXIMUM_CAPACITY) {
                // 生成当前扩容流程邮戳，n是当前数组的长度，当n相同时，邮戳肯定也是一样的，计算逻辑详见下面分析1
                int rs = resizeStamp(n);
                // sc小于0 标识已经在扩容中，因为在触发扩容时会通过CAS修改sc这个值
                // sc值是int类型，32位，低16位记录了当前进行扩容的线程数，高16位就是邮戳，这个逻辑见下面分析2
                if (sc < 0) {
                // (sc >>> RESIZE_STAMP_SHIFT) != rs 说明不是同一个扩容流程，放弃扩容
                // sc == rs + 1 || sc == rs + MAX_RESIZERS 这个条件是个bug，应该写成(sc >>> RESIZE_STAMP_SHIFT) == rs + 1 ||  (sc >>> RESIZE_STAMP_SHIFT) == rs + MAX_RESIZERS
                // 在jdk12中已被修复，oracle官网修复链接是 https://bugs.java.com/bugdatabase/view_bug.do?bug_id=JDK-8214427
                // (nt = nextTable) == null  有线程去扩容时，必然会生成nextTable，所以这里不需要处理
                // transferIndex <= 0 transferIndex是标记当前还未迁移的桶的下标，如果小于等于0，则表示已经迁移完，不需要做处理
                    if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                        sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                        transferIndex <= 0)
                        break;
                // 在进入扩容流程后会将sizeCtl值+1，sizeCtl的低16位表示当前并发扩容的线程数        
                    if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                        transfer(tab, nt);
                }
                // sc大于0 则表示没有进入扩容逻辑，则通过CAS将sizeCtl值修改成 (rs << RESIZE_STAMP_SHIFT) + 2
                // 这里的rs就是上面生成的扩容邮戳，这里会将rs向左位移16位，这样低16位用来记录并发扩容的线程数，高16位用来表示扩容邮戳，至于为什么要+2，我也没有理解...
                else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                             (rs << RESIZE_STAMP_SHIFT) + 2))
                    transfer(tab, null);
                s = sumCount();
            }
        }
    }

java复制代码static final class CounterCell {
        volatile long value;
        CounterCell(long x) { value = x; }
    }

java复制代码int rs = resizeStamp(n); 


static final int resizeStamp(int n) {
        return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
    }

java复制代码// tab是旧表，nextTab是一个两倍容量的空的新表
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
        // stide是步长的意思，会将旧表按照这个步长进行分段，在并发扩容时，每个线程只负责自己段内数据的转移
        int n = tab.length, stride;
        // NCPU是当前系统的内核数，如果内核数只有一个，那么就不需要进行并发扩容，因为扩容是个纯计算密集型的逻辑，只有一个核心的时候反而得不偿失，因为无法真正的并发，反而会额外付出线程上下文切换的开销
        // 这里步长最小是16，也就是说每个线程最少要负责16个桶的数据迁移，这个值设置的太小会导致并发线程数增多，从而导致线程间的竞争变大，这个竞争是只下面的一些CAS逻辑，比如对transferIndex、sizeCtl变量的cas操作
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; // subdivide range
        if (nextTab == null) {            // initiating
            try {
                @SuppressWarnings("unchecked")
                // 如果新表没有初始化，则新建一个双倍容量的新表
                Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
                nextTab = nt;
            } catch (Throwable ex) {      // try to cope with OOME
                sizeCtl = Integer.MAX_VALUE;
                return;
            }
            nextTable = nextTab;
            // 设置【开始数据转移】的桶的下标，从尾部的桶开始往头部逐个处理，将transferIndex设置为老表的length（比最后一个桶的下标大1，所以后面的代码会-1）
            transferIndex = n;
        }
        int nextn = nextTab.length;
        // 生成用于表示【扩容中】状态的节点
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
        // 线程每次根据步长从数组上截取一段桶，如果线程处理完自己截取的一段内的桶后，还有未处理的数据，则需要重新从数组上截取一段来处理
        // true则标识当前线程需要继续在老表的数组上截取新的一段桶来处理数据（可能没有线程来帮忙，就只能自己一个人干完了）
        boolean advance = true;
        // 标记是否已结束扩容，做收尾工作
        boolean finishing = false; // to ensure sweep before committing nextTab
        // i是当前线程需要转移的桶的下标，bound是当前线程负责的桶的最小下标
        for (int i = 0, bound = 0;;) {
            Node<K,V> f; int fh;
            // 这个while的逻辑就是为了检查当前线程负责的段内的桶是否都处理完毕，如果处理完毕，则看下老表的数据里是否还有未处理的桶，如果有未处理的桶，则再次截取一段来处理
            while (advance) {
                int nextIndex, nextBound;
                // 如果下一个桶的下标（--i是下一个需要操作的桶的下标）还在自己负责的段内，就不需要截取新段了，就继续处理下一个桶的数据
                // 如果已经结束，则不需要继续截取新的段
                if (--i >= bound || finishing)
                    advance = false;
                // transferIndex用来表示这个下标及其后面的桶都已经被其他线程处理了，新的线程需要从transferIndex往前截取自己需要负责的桶，如果transferIndex小于等于0说明桶都已经转移完毕，不需要再处理了    
                else if ((nextIndex = transferIndex) <= 0) {
                    i = -1;
                    advance = false;
                }
                // 以nextIndex（在上面已经赋值为transferIndex）为起始位置，往数组头部方向截取相应步长的段来转移数据，通过cas将transferIndex设置到新的下标
                else if (U.compareAndSwapInt
                         (this, TRANSFERINDEX, nextIndex,
                          nextBound = (nextIndex > stride ?
                                       nextIndex - stride : 0))) {
                    // cas成功后，设置当前线程负责的下标边界（比如负责下标32到48的桶，那么这个bound就是32）
                    bound = nextBound;
                    // cas成功后，设置当前线程开始处理的桶的下标（比如负责下标32到48的桶，那么这个i就是48）
                    // transferIndex默认是从tab.length开始取值，所以要减1来表示正确的下标
                    i = nextIndex - 1;
                    // cas成功则表示当前线程已经成功截取了自己需要负责的一段数据了，不需要再往前截取了
                    advance = false;
                }
            }
            // i是需要转移的桶的下标，n是老表的容量
            // i<0说明旧表中的桶都已经转移完毕
            // i>=n|| i + n >= nextn 不是很明白这个判断条件，正常情况下，i作为开始转移的桶的下标肯定会小于老表的容量的，因为转移的是老表内的桶
            if (i < 0 || i >= n || i + n >= nextn) {
                int sc;
                // 判断是否已经完成扩容，已完成扩容则做收尾逻辑
                if (finishing) {
                    // 完成扩容后，将引用设置为null
                    nextTable = null;
                    // 将table引用指向新表，这里的table是个volatile变量，所以这个赋值操作对其他线程是可见的
                    table = nextTab;
                    // 设置新的扩容阈值，将阈值设置为新容量的3/4
                    // 这里的n是老表的容量，因为是双倍扩容，所以新表容量是2n，下面计算的结果是2n-0.5n = 1.5n，也就是新表容量的3/4
                    sizeCtl = (n << 1) - (n >>> 1);
                    // 返回结果，扩容结束
                    return;
                }
                // 在扩容开始时，会将sizeCtl设置成一个负数，每次有新的线程并发扩容时，会将sizeCtl+1，而当有线程处理完扩容逻辑后，再减1，以此来判断是否是最后一个线程
                if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                // cas成功，则判断当前线程是不是最后一个完成扩容的线程，由最后一个完成扩容逻辑的线程将finishing和advance设为true，重新循环到上面的if(finishing)里的收尾逻辑
                // 这里减2是因为在执行扩容的入口处，第一个触发扩容的线程会负责将sc加2，至于为什么第一个扩容的线程要加2，而不是加1，这个没理解
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                        return;
                    finishing = advance = true;
                    i = n; // recheck before commit
                }
            }
            // 如果是空桶，则在老表对应的下标出放一个ForwardingNode，在有别的线程往这个空桶写数据时会感知到扩容过程，一起来扩容
            else if ((f = tabAt(tab, i)) == null)
                advance = casTabAt(tab, i, null, fwd);
            // ForwardingNode节点的hash值就是MOVED（在ForwardingNode的构造方法里会设置hash值为MOVED），说明已经有线程处理了这个桶内的数据
            else if ((fh = f.hash) == MOVED)
                advance = true; // already processed
            else {
            // 在桶上加锁，防止对同一个桶数据并发操作
                synchronized (f) {
                // 有点双重校验锁的味道，防止获得锁后，该桶内数据被别的线程插入了新的数据，因为这个f是在未加锁之前获取的node对象，在这期间，可能这个下标处插入了新数据
                // 比如有别的线程调用了put方法往这个桶内链表插入新节点，这时候这个桶的node就变成了新插入的数据node（put操作会生成新的node，并将新node的next引用指向原node）
                // 如果不做这层校验，会导致新加入到桶内的数据没有被处理，导致数据丢失
                    if (tabAt(tab, i) == f) {
                        Node<K,V> ln, hn;
                        // fh>=0表示是正常的链表
                        if (fh >= 0) {
                        // 这里需要注意的是在put操作里是通过hash&(n-1)来选取下标位置，表容量n都是2的幂，所以这里hash&n的结果只有两个要么是n要么是0
                        // 值为0时的节点在新表的i下标出，而值为n的节点需要迁移到新表的i+n下标下，因为是双倍扩容
                        // 所以老表下标为i的桶内的数据在迁移rehash时，一半仍然在下标为i的桶内，另一半在i+n的桶内，不会出现第三种情况
                            int runBit = fh & n;
                            Node<K,V> lastRun = f;
                            // 这个循环的目的有两个
                            // 1、遍历出整个链表尾部不需要改变next指针的最长链，这样可以将这个链整个搬到新桶内，不用再逐个遍历了
                            // 2、由于是将老的完整节点链条搬到新桶内，所以也就不需要创建新的node节点，减少迁移过程中的gc压力
                            for (Node<K,V> p = f.next; p != null; p = p.next) {
                                int b = p.hash & n;
                                if (b != runBit) {
                                    runBit = b;
                                    lastRun = p;
                                }
                            }
                            if (runBit == 0) {
                                ln = lastRun;
                                hn = null;
                            }
                            else {
                                hn = lastRun;
                                ln = null;
                            }
                            for (Node<K,V> p = f; p != lastRun; p = p.next) {
                                int ph = p.hash; K pk = p.key; V pv = p.val;
                                // 逐个遍历节点，0表示仍然放到下标为i的桶内的链表
                                // 这里每次都是生成新的node对象而不修改原node对象的next指针，这也是get()方法不用加锁的关键所在
                                // 但是会带来gc压力，所以才有上面的那次遍历，希望减少对象的创建
                                if ((ph & n) == 0)
                                    ln = new Node<K,V>(ph, pk, pv, ln);
                                // 否则就是放到下标为i+n的桶内的链表
                                else
                                    hn = new Node<K,V>(ph, pk, pv, hn);
                            }
                            // 设置新表的下标为i的桶内数据
                            setTabAt(nextTab, i, ln);
                            // 设置新表的下标为i+n的桶内数据
                            setTabAt(nextTab, i + n, hn);
                            // 将老表下标为i的桶内放上ForwardingNode对象，用来标识当前处于扩容过程
                            setTabAt(tab, i, fwd);
                            // 处理完后，将这个字段设置为true，以便走到上面的while(advance)里检查当前线程负责的数据是否处理完成，并且查看是否需要截取新段
                            advance = true;
                        }
                        // 红黑树结构的迁移，逻辑与链表差不多，也是将整棵树拆成两颗，一棵树放到下标为i的桶内，一棵放到下标i+n的桶内
                        else if (f instanceof TreeBin) {
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            TreeNode<K,V> lo = null, loTail = null;
                            TreeNode<K,V> hi = null, hiTail = null;
                            int lc = 0, hc = 0;
                            for (Node<K,V> e = t.first; e != null; e = e.next) {
                                int h = e.hash;
                                TreeNode<K,V> p = new TreeNode<K,V>
                                    (h, e.key, e.val, null, null);
                                if ((h & n) == 0) {
                                    if ((p.prev = loTail) == null)
                                        lo = p;
                                    else
                                        loTail.next = p;
                                    loTail = p;
                                    ++lc;
                                }
                                else {
                                    if ((p.prev = hiTail) == null)
                                        hi = p;
                                    else
                                        hiTail.next = p;
                                    hiTail = p;
                                    ++hc;
                                }
                            }
                            ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                                (hc != 0) ? new TreeBin<K,V>(lo) : t;
                            hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                                (lc != 0) ? new TreeBin<K,V>(hi) : t;
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                    }
                }
            }
        }
    }

java复制代码// Step 1 : ExecutableList 处理
C51- ActionQueue
    F51_01- LinkedHashMap<Class<? extends Executable>,ListProvider>
    M51_01- executeActions() : 执行所有当前排队的操作
        FOR- 循环所有的 ListProvider 
            - 通过当前 ListProvider 获取 ExecutableList , 调用 M51_02
    M51_02- executeActions(ExecutableList<E> list)
        FOR- 循环list , 调用 ExecutableList.execute() -> M52_01
 

// Step 2 : Entity 实体类的处理
C52- EntityInsertAction
    M52_01- execute()
        // Step 1 : 参数准备
        - EntityPersister persister = getPersister();
        - SharedSessionContractImplementor session = getSession();
        - Object instance = getInstance();
        - Serializable id = getId();
        // Step 2 : 执行 insert 流程
        - persister.insert( id, getState(), instance, session ) -> M53_01
        // Step 3 : insert 操作的执行
        - PersistenceContext persistenceContext = session.getPersistenceContext();
        - EntityEntry entry = persistenceContext.getEntry( instance )
        - entry.postInsert( getState() )
        //........ 后续操作在操作流程中再详细看

java复制代码// Step 1 : 核心中间处理器    
C53- AbstractEntityPersister
    M53_01- insert(Serializable id, Object[] fields, Object object, SharedSessionContractImplementor session)
    	1- session.getJdbcCoordinator().getStatementPreparer().prepareStatement( sql, callable ) -> M54_01
            ?- 构建 PreparedStatement
    	2- expectation.verifyOutcome(session.getJdbcCoordinator().getResultSetReturn().executeUpdate( insert ), insert, -1);
    M53_02-  insert(Serializable id,Object[] fields,boolean[] notNull,int j,String sql,Object object,SharedSessionContractImplementor session)
        1- session.getJdbcCoordinator().getStatementPreparer().prepareStatement( sql, callable )
            ?- 此处获取  statement
        

// Step 2 : statement 执行语句
C54- StatementPreparerImpl
    M54_01- prepareStatement(String sql, final boolean isCallable) -> M54_02
        - PreparedStatement preparedStatement = doPrepare() : 构建 statement
        - 执行 postProcess -> M54_03
    M54_02- buildPreparedStatementPreparationTemplate -> M55_01
    M54_03- postProcess
    	- jdbcCoordinator.getResourceRegistry().register( preparedStatement, true )
    
// ConnectionImpl 执行数据库连接
C55- ConnectionImpl
    M55_01- prepareStatement(String sql, int resultSetType, int resultSetConcurrency) 
    	?- 其中包括 sql 类型 , 返回类型 - >M55_02
    M55_02- clientPrepareStatement
    	 - ClientPreparedStatement.getInstance(getMultiHostSafeProxy(), nativeSql, this.database) -> PS:M55_02_01

// PS:M55_02_01 
com.mysql.cj.jdbc.ClientPreparedStatement: insert into user (isactive, orgid, remark, userlink, username, usertype, userid) values (** NOT SPECIFIED **, ** NOT SPECIFIED **, ** NOT SPECIFIED **, ** NOT SPECIFIED **, ** NOT SPECIFIED **, ** NOT SPECIFIED **, ** NOT SPECIFIED **)
    
C56- ResourceRegistryStandardImpl
    M56_01- register(Statement statement, boolean cancelable)
    	- Set<ResultSet> previousValue = xref.putIfAbsent( statement, Collections.EMPTY_SET );

// 最终处理类
C57- ResultSetReturnImpl
	M57_01- executeUpdate(PreparedStatement statement) : 执行 update 操作
            - jdbcCoordinator.getJdbcSessionOwner().getJdbcSessionContext().getObserver().jdbcExecuteStatementStart()

java复制代码C58- SessionEventListenerManagerImpl
    M58_01- jdbcExecuteStatementStart()
    	- 发起 SessionEventListener 处理 listener.jdbcExecuteStatementStart()
    	- 调用 executeUpdate()
    
C59- ClientPreparedStatement
    M59_01- executeUpdate() --> 核心调用为 M59_02
    M59_02- executeUpdateInternal(QueryBindings<?> bindings, boolean isReallyBatch)
        -  Message sendPacket = ((PreparedQuery<?>) this.query).fillSendPacket(bindings); : 此时已经生成一个 Message 对象
    
// 最终的处理流程 , SQL 的封装
C60- AbstractPreparedQuery
    M60_01- fillSendPacket(QueryBindings<?> bindings)
    	?- bindValues 核心逻辑 ->

java复制代码public <M extends Message> M fillSendPacket(QueryBindings<?> bindings) {
        synchronized (this) {
            // 绑定参数
            BindValue[] bindValues = bindings.getBindValues();
            // 准备最终返回的对象
            NativePacketPayload sendPacket = this.session.getSharedSendPacket();

            sendPacket.writeInteger(IntegerDataType.INT1, NativeConstants.COM_QUERY);

            boolean useStreamLengths = this.useStreamLengthsInPrepStmts.getValue();

            int ensurePacketSize = 0;

            String statementComment = this.session.getProtocol().getQueryComment();

            byte[] commentAsBytes = null;

            if (statementComment != null) {
                commentAsBytes = StringUtils.getBytes(statementComment, this.charEncoding);

                ensurePacketSize += commentAsBytes.length;
                ensurePacketSize += 6; // for /*[space] [space]*/
            }
            
            // 统计PacketSize
            for (int i = 0; i < bindValues.length; i++) {
                if (bindValues[i].isStream() && useStreamLengths) {
                    ensurePacketSize += bindValues[i].getStreamLength();
                }
            }
            
            // 检查底层缓冲区是否有足够的空间从当前位置开始存储additionalData字节。
            // 如果缓冲区的大小小于所需的大小，那么将以更大的大小重新分配它
            if (ensurePacketSize != 0) {
                sendPacket.ensureCapacity(ensurePacketSize);
            }

            if (commentAsBytes != null) {
                // 固定长度的字符串有一个已知的硬编码长度
                sendPacket.writeBytes(StringLengthDataType.STRING_FIXED, Constants.SLASH_STAR_SPACE_AS_BYTES);
                sendPacket.writeBytes(StringLengthDataType.STRING_FIXED, commentAsBytes);
                sendPacket.writeBytes(StringLengthDataType.STRING_FIXED, Constants.SPACE_STAR_SLASH_SPACE_AS_BYTES);
            }
            
            // 源 SQL 语句 : insert into user (isactive, orgid, remark, userlink, username, usertype, userid) values (?, ?, ?, ?, ?, ?, ?)
            byte[][] staticSqlStrings = this.parseInfo.getStaticSql();
            // bindValues 是参数列表 -> PS:M60_01_01
            for (int i = 0; i < bindValues.length; i++) {
                bindings.checkParameterSet(i);
				
                sendPacket.writeBytes(StringLengthDataType.STRING_FIXED, staticSqlStrings[i]);

                if (bindValues[i].isStream()) {
                    streamToBytes(sendPacket, bindValues[i].getStreamValue(), true, bindValues[i].getStreamLength(), useStreamLengths);
                } else {
                    sendPacket.writeBytes(StringLengthDataType.STRING_FIXED, bindValues[i].getByteValue());
                }
            }
		   // 组合为 NativeSQL 字符数组
            // get one byte to string -> insert into user (isactive, orgid, remark, userlink, username, usertype, userid) values (0, '1', 'step1 ', null, 'gang', null, 0)                                                   
            sendPacket.writeBytes(StringLengthDataType.STRING_FIXED, staticSqlStrings[bindValues.length]);

            return (M) sendPacket;
        }
}    


// 数组一 : 
for (int j = 0; j < staticSqlStrings.length; j++) {
    System.out.println("staticSqlStrings value [" + new String(staticSqlStrings[j]) + "]");
}

// 数组一结果>>>>>>>>>>>>>>>>>>: 
staticSqlStrings value [insert into user (isactive, orgid, remark, userlink, username, usertype, userid) values (]
staticSqlStrings value [, ]
staticSqlStrings value [, ]
staticSqlStrings value [, ]
staticSqlStrings value [, ]
staticSqlStrings value [, ]
staticSqlStrings value [, ]
staticSqlStrings value [)]

// 数组二  :
for (int j = 0; j < bindValues.length; j++) {
    System.out.println("name [" + i + "]-- value [" + new String(bindValues[j].getByteValue()) + "]");
}

// 数组二结果>>>>>>>>>>>>>>>>>>>
name [0]-- value [0]
name [1]-- value ['1']
name [2]-- value ['step1 ']
name [3]-- value [null]
name [4]-- value ['gang']
name [5]-- value [null]
name [6]-- value [0]
                                                                                                                 
// 总结 : 至此 , JPA 的SQL 解析就完成了 , 可以看到 , 是通过2个数组互相拼装完成后 , 下面我们分析一下其中的几个关键节点

java复制代码//  先看一下体系
C- ClientPreparedStatement
    E- StatementImpl
        F- protected Query query;
    MC- ClientPreparedStatement(JdbcConnection conn, String sql, String catalog, ParseInfo cachedParseInfo)
        - ((PreparedQuery<?>) this.query).checkNullOrEmptyQuery(sql);
        - ((PreparedQuery<?>) this.query).setOriginalSql(sql);
        - ((PreparedQuery<?>) this.query).setParseInfo(cachedParseInfo != null ? cachedParseInfo : new ParseInfo(sql, this.session, this.charEncoding));

// 可以看到 , 在 ClientPreparedStatement 的构造方法中 , ParseInfo 就生成了 , 所以核心还是在 ParseInfo 对象中


C63- ParseInfo
    MC63_01- ParseInfo(String sql, Session session, String encoding, boolean buildRewriteInfo)
        ?- 在该构造方法中 , 对 sql 进行了解析

java复制代码 public ParseInfo(String sql, Session session, String encoding, boolean buildRewriteInfo) {

        try {
            // Step 1 : 保证 sql 不为空
            if (sql == null) {
                throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("PreparedStatement.61"),
                        session.getExceptionInterceptor());
            }
            
            // Step 2 : 字符编码和时间
            this.charEncoding = encoding;
            this.lastUsed = System.currentTimeMillis();

            // 直译 : 获取标识符引用字符串 , 以下是一个完整体系 , 为了得到 quotedIdentifierChar
            String quotedIdentifierString = session.getIdentifierQuoteString();
            char quotedIdentifierChar = 0;
            if ((quotedIdentifierString != null) && !quotedIdentifierString.equals(" ") && (quotedIdentifierString.length() > 0)) {
                quotedIdentifierChar = quotedIdentifierString.charAt(0);
            }
            
            // sql 长度 , 部分框架会校验长度来保证安全性 , 像个 sign 试的 , 猜测可能也是这个原因
            this.statementLength = sql.length();

            ArrayList<int[]> endpointList = new ArrayList<>();
            boolean inQuotes = false;
            char quoteChar = 0;
            boolean inQuotedId = false;
            int lastParmEnd = 0;
            int i;

            // 没有反斜杠转义集
            boolean noBackslashEscapes = session.getServerSession().isNoBackslashEscapesSet();
            
            // 发现了一个有趣的地方 , 这里会去查找真正的起点 , 这也意味着实际上我的 SQL 可以有注释 , 而且不会解析 ???
            // PS : 想多了 ..... QuerySyntaxException 已经做了拦截
            // StringUtils.startsWithIgnoreCaseAndWs(sql, "/*")
            // statementStartPos = sql.indexOf("*/");
            // StringUtils.startsWithIgnoreCaseAndWs(sql, "--") || StringUtils.startsWithIgnoreCaseAndWs(sql, "#")
            this.statementStartPos = findStartOfStatement(sql);
            
            // Step 3 : 字符级逐字处理
            // - 扫描操作类型 (Insert / select 等)
            // - 扫描 '' "" 字符 ,跳过
            // - 扫描 ? 占位符 , 记录位置
            // - 扫描 ; 及 \n \r 换行符 , 直接跳出循环
            // - 
            for (i = this.statementStartPos; i < this.statementLength; ++i) {
                char c = sql.charAt(i);

                if ((this.firstStmtChar == 0) && Character.isLetter(c)) {
                    // 确定我们正在执行的语句类型 , 即是 insert / update / select 等
                    this.firstStmtChar = Character.toUpperCase(c);

                    // 如果不是INSERT语句，则不需要搜索“ON DUPLICATE KEY UPDATE”
                    if (this.firstStmtChar == 'I') {
                        this.locationOfOnDuplicateKeyUpdate = getOnDuplicateKeyLocation(sql,
                                session.getPropertySet().getBooleanProperty(PropertyKey.dontCheckOnDuplicateKeyUpdateInSQL).getValue(),
                                session.getPropertySet().getBooleanProperty(PropertyKey.rewriteBatchedStatements).getValue(),
                                session.getServerSession().isNoBackslashEscapesSet());
                        // 相反 , 如果是 insert , 此处需要处理  DUPLICATE KEY
                        // 当insert已经存在的记录时，执行Update
                        this.isOnDuplicateKeyUpdate = this.locationOfOnDuplicateKeyUpdate != -1;
                    }
                }
                
                // 当 \\ 时 , 下一个字符为转义字符 , 即转义字符的处理 == 不处理 , 跳过
                if (!noBackslashEscapes && c == '\\' && i < (this.statementLength - 1)) {
                    i++;
                    continue; 
                }

                // 
                if (!inQuotes && (quotedIdentifierChar != 0) && (c == quotedIdentifierChar)) {
                    inQuotedId = !inQuotedId;
                } else if (!inQuotedId) {
                    //  只有在不使用引号标识符时才使用引号
                    if (inQuotes) {
                        // 处理 ' 和 " 字符 , 这里也意味着2种字符均可
                        // 这里可能存在问题 , if 和 else if 条件一样
                        if (((c == '\'') || (c == '"')) && c == quoteChar) {
                            if (i < (this.statementLength - 1) && sql.charAt(i + 1) == quoteChar) {
                                i++;
                                continue; // inline quote escape
                            }

                            inQuotes = !inQuotes;
                            quoteChar = 0;
                        } else if (((c == '\'') || (c == '"')) && c == quoteChar) {
                            inQuotes = !inQuotes;
                            quoteChar = 0;
                        }
                    } else {
                        // 对 # 号进行处理
                        if (c == '#' || (c == '-' && (i + 1) < this.statementLength && sql.charAt(i + 1) == '-')) {
                            // 运行到语句结束，或换行符，以先出现者为准
                            int endOfStmt = this.statementLength - 1;

                            for (; i < endOfStmt; i++) {
                                c = sql.charAt(i);
                             // 这里时换行符或者结尾
                                if (c == '\r' || c == '\n') {
                                    break;
                                }
                            }

                            continue;
                        } else if (c == '/' && (i + 1) < this.statementLength) {
                            // Comment?
                            char cNext = sql.charAt(i + 1);

                            if (cNext == '*') {
                                i += 2;

                                for (int j = i; j < this.statementLength; j++) {
                                    i++;
                                    cNext = sql.charAt(j);

                                    if (cNext == '*' && (j + 1) < this.statementLength) {
                                        if (sql.charAt(j + 1) == '/') {
                                            i++;

                                            if (i < this.statementLength) {
                                                c = sql.charAt(i);
                                            }

                                            break; // comment done
                                        }
                                    }
                                }
                            }
                        } else if ((c == '\'') || (c == '"')) {
                            inQuotes = true;
                            quoteChar = c;
                        }
                    }
                }

                if (!inQuotes && !inQuotedId) {
                    // 此处处理 ? 占位符
                    if ((c == '?')) {
                        // 记录当前占位符字符
                        endpointList.add(new int[] { lastParmEnd, i });
                        // 字符 + 1 , 处理后续字符
                        lastParmEnd = i + 1;
                        
                        // 是否在重复密钥更新
                      // 重复密钥更新的位置
                        if (this.isOnDuplicateKeyUpdate && i > this.locationOfOnDuplicateKeyUpdate) {
                            this.parametersInDuplicateKeyClause = true;
                        }
                    // 处理结尾符号
                    } else if (c == ';') {
                        int j = i + 1;
                        if (j < this.statementLength) {
                            for (; j < this.statementLength; j++) {
                                if (!Character.isWhitespace(sql.charAt(j))) {
                                    break;
                                }
                            }
                            if (j < this.statementLength) {
                                this.numberOfQueries++;
                            }
                            i = j - 1;
                        }
                    }
                }
            }
            
            // 自此 SQL 的扫描已经完成 , 后续进行 SQL 的切割
            
            if (this.firstStmtChar == 'L') {
                if (StringUtils.startsWithIgnoreCaseAndWs(sql, "LOAD DATA")) {
                    this.foundLoadData = true;
                } else {
                    this.foundLoadData = false;
                }
            } else {
                this.foundLoadData = false;
            }

            endpointList.add(new int[] { lastParmEnd, this.statementLength });
            this.staticSql = new byte[endpointList.size()][];
            this.hasPlaceholders = this.staticSql.length > 1;

            // Step 5 : 此处按照扫描的节点进行字符串切割
            for (i = 0; i < this.staticSql.length; i++) {
                int[] ep = endpointList.get(i);
                int end = ep[1];
                int begin = ep[0];
                int len = end - begin;

                if (this.foundLoadData) {
                    this.staticSql[i] = StringUtils.getBytes(sql, begin, len);
                } else if (encoding == null) {
                    byte[] buf = new byte[len];

                    for (int j = 0; j < len; j++) {
                        buf[j] = (byte) sql.charAt(begin + j);
                    }

                    this.staticSql[i] = buf;
                } else {
                    // 切割字符串
                    this.staticSql[i] = StringUtils.getBytes(sql, begin, len, encoding);
                }
            }
            
            // PS : 切割的结果即为上文数组一的结果
        } catch (StringIndexOutOfBoundsException oobEx) {
            throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("PreparedStatement.62", new Object[] { sql }), oobEx,
                    session.getExceptionInterceptor());
        }

        if (buildRewriteInfo) {
            this.canRewriteAsMultiValueInsert = this.numberOfQueries == 1 && !this.parametersInDuplicateKeyClause
                    && canRewrite(sql, this.isOnDuplicateKeyUpdate, this.locationOfOnDuplicateKeyUpdate, this.statementStartPos);
            if (this.canRewriteAsMultiValueInsert && session.getPropertySet().getBooleanProperty(PropertyKey.rewriteBatchedStatements).getValue()) {
                buildRewriteBatchedParams(sql, session, encoding);
            }
        }

    }

java复制代码
// 以及还有一个 , 最初 的 sql 是怎么通过 Entity 翻译过来的

C53- AbstractEntityPersister
    M53_01- insert(Serializable id, Object[] fields, Object object, SharedSessionContractImplementor session)
        P- fields : 实体类值数组
        P- object : 当前实体类   
    M53_03- doLateInit : 初始化 Persister -> 
    
    
    public void insert(Serializable id, Object[] fields, Object object, SharedSessionContractImplementor session) {
        // 生成应用内存中任何预插入值
        preInsertInMemoryValueGeneration( fields, object, session );

         // 获取 Table 数量   
        final int span = getTableSpan();
        if ( entityMetamodel.isDynamicInsert() ) {
            // F对于dynamic-insert="true"的情况，需要生成INSERT SQL
            boolean[] notNull = getPropertiesToInsert( fields );
            for ( int j = 0; j < span; j++ ) {
                insert( id, fields, notNull, j, generateInsertString( notNull, j ), object, session );
            }
        }
        else {
            // 对于dynamic-insert="false"的情况，使用静态SQL
            for ( int j = 0; j < span; j++ ) {
                 // getSQLInsertStrings()[j] 方法 , 这里直接从获取得属性 sqlInsertStrings -> PS:M53_01_01
                insert( id, fields, getPropertyInsertability(), j, getSQLInsertStrings()[j], object, session );
            }
        }
    }

java复制代码// 这些属性值是在以下流程中生成得 : 
C53- AbstractEntityPersister
    M53_03- doLateInit : 初始化 Persister 
        
// 主要流程点 : 
C- LocalContainerEntityManagerFactoryBean # afterPropertiesSet
C- AbstractEntityManagerFactoryBean # buildNativeEntityManagerFactory
C- AbstractEntityManagerFactoryBean # createNativeEntityManagerFactory
C- SpringHibernateJpaPersistenceProvider # createContainerEntityManagerFactory
C- SessionFactoryBuilderImpl # build    
C- SessionFactoryImpl # init
C- MetamodelImpl # initialize

// 最终流程点 : 执行 AbstractEntityPersister 初始化    
C- AbstractEntityPersister # postInstantiate

java复制代码C53- AbstractEntityPersister
    M53_04- generateInsertString        
        
protected String generateInsertString(boolean identityInsert, boolean[] includeProperty, int j) {

        // 此处 Insert 对象包含方言和表明
        Insert insert = new Insert( getFactory().getDialect() )
                .setTableName( getTableName( j ) );

        // add normal properties
        for ( int i = 0; i < entityMetamodel.getPropertySpan(); i++ ) {
            // the incoming 'includeProperty' array only accounts for insertable defined at the root level, it
            // does not account for partially generated composites etc.  We also need to account for generation
            // values
            if ( isPropertyOfTable( i, j ) ) {
                if ( !lobProperties.contains( i ) ) {
                    final InDatabaseValueGenerationStrategy generationStrategy = entityMetamodel.getInDatabaseValueGenerationStrategies()[i];
                    if ( generationStrategy != null && generationStrategy.getGenerationTiming().includesInsert() ) {
                        if ( generationStrategy.referenceColumnsInSql() ) {
                            final String[] values;
                            if ( generationStrategy.getReferencedColumnValues() == null ) {
                                values = propertyColumnWriters[i];
                            }
                            else {
                                final int numberOfColumns = propertyColumnWriters[i].length;
                                values = new String[numberOfColumns];
                                for ( int x = 0; x < numberOfColumns; x++ ) {
                                    if ( generationStrategy.getReferencedColumnValues()[x] != null ) {
                                        values[x] = generationStrategy.getReferencedColumnValues()[x];
                                    }
                                    else {
                                        values[x] = propertyColumnWriters[i][x];
                                    }
                                }
                            }
                            insert.addColumns( getPropertyColumnNames( i ), propertyColumnInsertable[i], values );
                        }
                    }
                    else if ( includeProperty[i] ) {
                          // 插入 Columns
                        insert.addColumns(
                                getPropertyColumnNames( i ),
                                propertyColumnInsertable[i],
                                propertyColumnWriters[i]
                        );
                    }
                }
            }
        }

        // 添加鉴频器 , 简单点说就是为了让一个数据库对象映射为多种不同得 JavaBean 
        // Discriminator是一种基于单个数据库表中包含的数据的继承策略。
        @ https://www.waitingforcode.com/jpa/single-table-inheritance-with-discriminator-in-jpa/read#:~:text=Discriminator%20is%20an%20inheritance%20strategy%20based%20on%20data,this%20type%20of%20inheritance%2C%20JPA%20provides%20two%20annotations%3A
        
        
        if ( j == 0 ) {
            addDiscriminatorToInsert( insert );
        }

        // 如果需要插入主键 , 则添加
        if ( j == 0 && identityInsert ) {
            insert.addIdentityColumn( getKeyColumns( 0 )[0] );
        }
        else {
            insert.addColumns( getKeyColumns( j ) );
        }
        
        // 插入前缀
        if ( getFactory().getSessionFactoryOptions().isCommentsEnabled() ) {
            insert.setComment( "insert " + getEntityName() );
        }

        for ( int i : lobProperties ) {
            if ( includeProperty[i] && isPropertyOfTable( i, j ) ) {
                // 此属性属于表，将被插入
                insert.addColumns(
                        getPropertyColumnNames( i ),
                        propertyColumnInsertable[i],
                        propertyColumnWriters[i]
                );
            }
        }

        String result = insert.toStatementString();

        // append the SQL to return the generated identifier
        if ( j == 0 && identityInsert && useInsertSelectIdentity() ) { //TODO: suck into Insert
            result = getFactory().getDialect().getIdentityColumnSupport().appendIdentitySelectToInsert( result );
        }

        return result;
    }

c复制代码/********************* 单链表的常规操作 ****************************/

LinkList CreateHeadListH();            // 头插法创建单链表
LinkList CreateHeadListT();            // 尾插法创建单链表
int      ListEmpty();                  // 单链表判空
int      ListLength();                 // 求单链表长度
void     Travel();                     // 遍历单链表
int      InsertNode();                 // 插入结点
int      DeleteNode();                 // 删除结点
ElemType GetElem();                    // 按址查值
int      GetLocate();                  // 按值查址
int      RemoveRepeat();               // 去除重复的值

/*****************************************************************/

c复制代码#include "stdio.h"
#include "malloc.h"


#define TRUE  1
#define FALSE 0

typedef int ElemType;        // 单链表存储元素的数据类型

// 定义单链表结构体
typedef struct Node(){
    ElemType data;            // 单链表结点数据域
    struct Node *next;        // 单链表结点地址域（指向下一个结点）
}*LinkList, Node;

c复制代码/*
 *    头插法创建单链表(带头结点)
 *    datas 接收数组，用于赋值链表的结点数据
 *    len datas数组的长度，便于遍历
*/
LinkList CreateHeadListH(ElemType *datas, int len){
    // 创建头结点
    LinkList head, new_node;
    head = (LinkList)malloc(sizeof(Node));
    // head -> data = len;    // 可以把链表长度存在头结点的数据域中
    head -> next = NULL;

    // 分配新节点并用头插法链接起来
    for(int i=0;i<len;i++){
        new_node = (LinkList)malloc(sizeof(Node));
        new_node -> data = datas[i];
        new_node -> next = head -> next;
        head -> next = new_node;
    }
    return head;
}

c复制代码/*
 *    尾插法创建单链表(带头结点)
 *    datas 接收数组，用于赋值链表的结点数据
 *    len datas数组的长度，便于遍历
*/
LinkList CreateHeadListT(ElemType *datas, int len){
    // 创建头结点
    LinkList head, p, new_node;
    head = (LinkList)malloc(sizeof(Node));
    head -> next = NULL;
    p = head;

    // 分配新节点并用尾插法链接起来
    for(int i=0;i<len;i++){
        new_node = (LinkList)malloc(sizeof(Node));
        new_node -> data = datas[i];
        new_node -> next = NULL;
        p -> next = new_node;
        p = new_node;
    }
    return head;
}

c复制代码/*
 *    单链表判空
 *    list 接收单链表
*/
int ListEmpty(LinkList list){
    return (list == NULL || list -> next == NULL);
}

c复制代码/*
 *    计算单链表的长度
 *    list 接收单链表
*/
int ListLength(LinkList list){
    LinkList p = list;
    int len = 0;
    if(ListEmpty(list)){
        return len;
    }
    p = p -> next;
    while(p != NULL){
        len ++;
        p = p -> next;
    }
    return len;
}

c复制代码/*
 * 遍历单链表
 * list 单链表
*/
void Travel(LinkList list){
    LinkList p = list;
    if(!ListEmpty(list)){    // 单链表非空情况下才遍历
        p = p -> next;        // 因为带头结点单链表所以要先走一步
        while(p != NULL){
            printf("%d\t", p -> data);
            p = p -> next;
        }
        printf("\n");
    }
}

c复制代码int main(int argc, char const *argv[])
{
    int datas[] = {2, 4, 6, 8, 10};
    // 动态计算datas数组的长度
    // 数组长度 = 数组的总空间大小 / 数组中每个元素所占空间大小
    int len = sizeof(datas) / sizeof(datas[0]);

    printf("头插法构造单链表\n");
    LinkList list_h = CreateHeadListH(datas, len);
    printf("ListEmpty():%d\n", ListEmpty(list_h));        // 判空
    printf("ListLength():%d\n", ListLength(list_h));    // 求长
    printf("Travel():");                                
    Travel(list_h);                                        // 遍历

    printf("\n尾插法构造单链表\n");
    LinkList list_t = CreateHeadListT(datas, len);
    printf("ListEmpty():%d\n", ListEmpty(list_t));
    printf("ListLength():%d\n", ListLength(list_t));
    printf("Travel():");
    Travel(list_t);
    return 0;
}

C复制代码头插法构造单链表
ListEmpty():0
ListLength():5
Travel():10     8       6       4       2

尾插法构造单链表
ListEmpty():0
ListLength():5
Travel():2      4       6       8       10

请按任意键继续. . .

c复制代码/*
 * 单链表指定位置插入结点
 * list 单链表
 * data 要插入的结点的数据
 * pos  结点插入的位置（逻辑位置（1,2,3,...））
*/
int InsertNode(LinkList list, ElemType data, int pos){
    LinkList p = list, new_node;
    if(ListEmpty(list)){
        printf("空单链表\n");
        return FALSE;
    }

    // 判断插入位置是否合理
    if(pos <= 0 || pos > ListLength(list) + 1){
        printf("插入位置不合理\n");
        return FALSE;
    }
     
    // 寻找到要插入位置的前一个结点
    for(int i = 0; i < pos - 1 && p != NULL; i++){
        p = p -> next;
    }

    // 准备新结点
    new_node = (LinkList)malloc(sizeof(Node));
    new_node -> data = data;

    // 此时p就是要插入位置的前一个结点，p -> next就是要插入位置的结点
    new_node -> next = p -> next;    
    p -> next = new_node;
    return TRUE;
}

c复制代码new_code3 -> next = new_code1 -> next;
new_code1 -> next = new_code3;

c复制代码new_code1 -> next = new_code3;
// 此时new_code1 -> next 等于 new_code3, now_code3 -> next = new_code3 没有达到链接
new_code3 -> next = new_code1 -> next;

c复制代码/*
 * 单链表指定位置删除结点
 * list 单链表
 * *val 用来存储删除结点的数据
 * pos  结点删除的位置（逻辑位置（1,2,3,...））
*/
int DeleteNode(LinkList list, ElemType *val, int pos){
    LinkList p = list, r;
    if(ListEmpty(list)){
        printf("空单链表\n");
        return FALSE;
    }

    // 判断删除位置是否合理
    if(pos <= 0 || pos > ListLength(list)){
        printf("删除位置不合理\n");
        return FALSE;
    }

    // 寻找到要删除结点的前一个位置
    for(int i = 0; i < pos - 1 && p != NULL; i++){
        p = p -> next;
    }

    r = p -> next;            // 记录要删除的结点
    *val = r -> data;        // 把删除结点的数据利用指针返回去
    p -> next = r -> next;    // 把链表重新链接起来
    free(r);                // 释放删除结点的资源
    return TRUE;
}

c复制代码r = new_code1 - > next;                
new_code1 -> next = r -> next;        // new_code1 -> next = new_code2 -> next;
free(r);

c复制代码new_code1 -> next = r -> next;            // 此时r -> next 等于 new_code2
            ↓↓     
new_code1 -> next = new_code2 -> next;    // new_code2 -> next 等于 new_code3
            ↓↓
new_code1 -> next = new_code3;

c复制代码/*
 *    根据指定位置求结点的值(没有找到返回 0 )
 *    list 单链表
 *    pos  结点位置（逻辑位置（1,2,3,...））
*/
ElemType GetElem(LinkList list, int pos){
    LinkList p = list;
    if(ListEmpty(list)){
        printf("空单链表\n");
        return FALSE;
    }
    if(pos <= 0 || pos > ListLength(list)){
        printf("位置不合理\n");
        return FALSE;
    }

    for(int i = 0; i < pos && p !=NULL; i++){
        p = p -> next;
    }
    return p -> data;
}

c复制代码/*
 *    根据指定的值寻找结点的位置
 *    (如果有多个值相同返回第一个找到的结点的位置, 没找到则返回 0)
 *    list 单链表
 *  data 要查找的值
*/
int GetLocate(LinkList list, ElemType data){
    LinkList p = list;
    int pos = 0;
    if(ListEmpty(list)){
        return FALSE;
    }
    p = p -> next;
    while(p != NULL){
        pos ++;
        if(p -> data == data){
            return pos;
        }
        p = p -> next;
    }
    return FALSE;
}

c复制代码/*
 *    去除单链表中重复的值（重复的值只保留一个）
 *    list 单链表
 *  返回值：对单链表进行了去重操作返回 1，否则返回 0
*/
int RemoveRepeat(LinkList list){
    LinkList p = list, q, r;
    int flag = 0;
    if(ListEmpty(list)){
        return FALSE;
    }

    p = p -> next;

    while(p != NULL){
        q = p;
        while(q != NULL && q -> next != NULL){
            if(p -> data == q -> next -> data){
                r = q -> next;    // 记录值相同的结点
                q -> next = r -> next;
                free(r);
                flag = 1;
            }else{
                q = q -> next;
            }
        }
        p = p -> next;
    }
    return flag;
}