Merge pull request '整合master' (#18) from develop into master

master
pbensvpw6 8 months ago
commit f624704b19

@ -1,17 +1,27 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- 这是XML声明指定了XML的版本为1.0以及字符编码为UTF-8用于告诉解析器如何正确解析该XML文件 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 这是文档类型定义DOCTYPE声明用于指定该XML文档遵循的文档类型定义。这里表明该Mapper XML遵循MyBatis的Mapper 3.0的DTD规范并且指定了DTD文件的URL地址以便解析器可以根据该DTD来验证XML文档的结构是否正确 -->
<mapper namespace="com.yf.exam.modules.exam.mapper.ExamDepartMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识通常是对应Mapper接口的全限定名。这里表示与com.yf.exam.modules.exam.mapper.ExamDepartMapper接口相关联 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exam.modules.exam.entity.ExamDepart">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果映射到指定的Java对象这里是ExamDepart类型。id属性是该结果映射的唯一标识 -->
<id column="id" property="id" />
<!-- 定义了主键的映射关系column属性指定了数据库表中的列名这里是id列property属性指定了要映射到的Java对象中的属性名这里也是id属性即将数据库表中的id列的值赋给Java对象的id属性 -->
<result column="exam_id" property="examId" />
<!-- 定义了普通列的映射关系将数据库表中的exam_id列的值赋给Java对象的examId属性 -->
<result column="depart_id" property="departId" />
<!-- 同样是定义普通列的映射关系把数据库表中的depart_id列的值赋给Java对象的departId属性 -->
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用。这里列出了通用查询时要选择的数据库表列名用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`exam_id`,`depart_id`
</sql>
</mapper>
</mapper>

@ -1,26 +1,46 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0字符编码采用UTF-8这是告诉解析器如何正确解析该XML文件的基本信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.exam.mapper.ExamMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识这里对应着com.yf.exam.modules.exam.mapper.ExamMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exam.modules.exam.entity.Exam">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果准确地映射到指定的Java对象这里是Exam类型。id属性为该结果映射的唯一标识符 -->
<id column="id" property="id" />
<!-- 定义主键的映射关系将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名property属性指定要映射到的Java对象中的属性名 -->
<result column="title" property="title" />
<!-- 把数据库表中的title列的值映射到Java对象的title属性 -->
<result column="content" property="content" />
<!-- 将数据库表中的content列的值映射到Java对象的content属性 -->
<result column="open_type" property="openType" />
<!-- 映射数据库表中的open_type列到Java对象的openType属性注意这里在Java对象中属性名采用了驼峰命名法与数据库列名可能存在格式差异 -->
<result column="state" property="state" />
<!-- 把数据库表中的state列的值映射到Java对象的state属性 -->
<result column="time_limit" property="timeLimit" />
<!-- 映射数据库表中的time_limit列到Java对象的timeLimit属性 -->
<result column="start_time" property="startTime" />
<!-- 将数据库表中的start_time列的值映射到Java对象的startTime属性 -->
<result column="end_time" property="endTime" />
<!-- 把数据库表中的end_time列的值映射到Java对象的endTime属性 -->
<result column="create_time" property="createTime" />
<!-- 映射数据库表中的create_time列到Java对象的createTime属性 -->
<result column="update_time" property="updateTime" />
<!-- 将数据库表中的update_time列的值映射到Java对象的updateTime属性 -->
<result column="total_score" property="totalScore" />
<!-- 把数据库表中的total_score列的值映射到Java对象的totalScore属性 -->
<result column="total_time" property="totalTime" />
<!-- 映射数据库表中的total_time列到Java对象的totalTime属性 -->
<result column="qualify_score" property="qualifyScore" />
</resultMap>
<!-- 将数据库表中的qualify_score列的值映射到Java对象的qualifyScore属性 -->
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用这里列出了通用查询时要从数据库表中选择的列名使用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`title`,`content`,`open_type`,`join_type`,`level`,`state`,`time_limit`,`start_time`,`end_time`,`create_time`,`update_time`,`total_score`,`total_time`,`qualify_score`
</sql>
@ -28,69 +48,97 @@
<resultMap id="ReviewResultMap"
type="com.yf.exam.modules.exam.dto.response.ExamReviewRespDTO"
extends="BaseResultMap">
<!-- 定义一个名为ReviewResultMap的结果映射它的类型是ExamReviewRespDTO并且通过extends属性继承了BaseResultMap意味着它会包含BaseResultMap中定义的所有映射关系在此基础上还可以添加新的映射关系 -->
<result column="examUser" property="examUser" />
<!-- 新增的映射关系将数据库表中的examUser列的值映射到Java对象的examUser属性 -->
<result column="unreadPaper" property="unreadPaper" />
<!-- 将数据库表中的unreadPaper列的值映射到Java对象的unreadPaper属性 -->
</resultMap>
<resultMap id="ListResultMap"
type="com.yf.exam.modules.exam.dto.ExamDTO"
extends="BaseResultMap">
extends="BaseResultMap">
<!-- 定义名为ListResultMap的结果映射类型为ExamDTO同样继承了BaseResultMap可在其基础上进行扩展但这里暂时没有添加新的映射关系 -->
</resultMap>
<select id="paging" resultMap="ListResultMap">
<!-- 定义一个名为paging的查询语句其结果将按照ListResultMap定义的映射关系进行映射 -->
SELECT * FROM el_exam
<where>
<!-- <where>标签用于动态生成WHERE子句根据条件判断是否添加相应的条件语句 -->
<if test="query!=null">
<!-- <if>标签用于条件判断这里判断传入的参数query是否不为空 -->
<if test="query.title!=null and query.title!=''">
<!-- 进一步判断query对象中的title属性是否不为空且不为空字符串如果满足条件则添加以下WHERE子句条件 -->
AND title LIKE CONCAT('%',#{query.title},'%')
<!-- 使用LIKE关键字进行模糊查询将查询条件中的title值与数据库表中的title列进行模糊匹配#{query.title}是MyBatis的参数占位符会被实际传入的参数值替换 -->
</if>
<if test="query.openType!=null">
<!-- 判断query对象中的openType属性是否不为空如果是则添加以下WHERE子句条件 -->
AND open_type = #{query.openType}
<!-- 将数据库表中的open_type列与传入的query.openType参数值进行精确匹配 -->
</if>
<if test="query.startTime!=null">
<!-- 判断query对象中的startTime属性是否不为空如果是则添加以下WHERE子句条件 -->
AND start_time >= #{query.startTime}
<!-- 将数据库表中的start_time列与传入的query.startTime参数值进行比较筛选出大于等于该值的数据 -->
</if>
<if test="query.endTime!=null">
<!-- 判断query对象中的endTime属性是否不为空如果是则添加以下WHERE子句条件 -->
AND end_time &lt;= #{query.endTime}
<!-- 将数据库表中的end_time列与传入的query.endTime参数值进行比较筛选出小于等于该值的数据注意这里的&lt;是XML中表示小于号<的转义字符因为在XML中<有特殊含义,需要转义 -->
</if>
</if>
</where>
</select>
<select id="reviewPaging" resultMap="ReviewResultMap">
<!-- 定义一个名为reviewPaging的查询语句其结果将按照ReviewResultMap定义的映射关系进行映射 -->
SELECT ex.*,
(SELECT COUNT(DISTINCT user_id) FROM el_paper WHERE exam_id=ex.id) as examUser,
<!-- 通过子查询计算出与当前考试ex.id相关的不同用户ID的数量并将其命名为examUser这个值将根据ReviewResultMap的映射关系映射到对应的Java对象属性上 -->
(SELECT COUNT(0) FROM el_paper WHERE exam_id=ex.id AND state=1) as unreadPaper
<!-- 通过子查询计算出与当前考试ex.id相关且状态为1的记录数量并将其命名为unreadPaper同样会根据映射关系映射到Java对象属性上 -->
FROM el_exam ex
WHERE ex.has_saq=1
<!-- 添加WHERE子句条件筛选出el_exam表中has_saq列值为1的记录 -->
</select>
<resultMap id="OnlineResultMap"
type="com.yf.exam.modules.exam.dto.response.ExamOnlineRespDTO"
extends="BaseResultMap">
<!-- 定义名为OnlineResultMap的结果映射类型为ExamOnlineRespDTO继承了BaseResultMap可在此基础上扩展但这里暂未添加新映射关系 -->
</resultMap>
<select id="online" resultMap="OnlineResultMap">
<!-- 定义一个名为online的查询语句其结果将按照OnlineResultMap定义的映射关系进行映射 -->
SELECT ex.*
FROM el_exam ex
LEFT JOIN el_exam_depart dept ON ex.id=dept.exam_id AND ex.open_type=2
<!-- 使用LEFT JOIN连接el_exam表和el_exam_depart表连接条件是ex.id等于dept.exam_id且ex.open_type等于2 -->
LEFT JOIN sys_user uc ON uc.depart_id=dept.depart_id
<!-- 再使用LEFT JOIN连接上一步的结果和sys_user表连接条件是uc.depart_id等于dept.depart_id -->
WHERE ex.state=0 AND (ex.open_type=1 OR ex.open_type=3 OR uc.id='{{userId}}')
<!-- 添加WHERE子句条件筛选出el_exam表中state列值为0且满足open_type等于1或open_type等于3或uc.id等于传入的{{userId}}参数值)的记录 -->
<if test="query!=null">
<!-- 判断传入的参数query是否不为空 -->
<if test="query.title!=null and query.title!=''">
<!-- 进一步判断query对象中的title属性是否不为空且不为空字符串如果满足条件则添加以下WHERE子句条件 -->
AND ex.title LIKE CONCAT('%',#{query.title},'%')
<!-- 使用LIKE关键字进行模糊查询将查询条件中的title值与数据库表中的ex.title列进行模糊匹配#{query.title}是MyBatis的参数占位符会被实际传入的参数值替换 -->
</if>
<if test="query.openType!=null">
<!-- 判断query对象中的openType属性是否不为空如果是则添加以下WHERE子句条件 -->
AND ex.open_type=#{query.openType}
<!-- 将数据库表中的ex.open_type列与传入的query.openType参数值进行精确匹配 -->
</if>
</if>
</select>
</mapper>
</mapper>

@ -1,38 +1,63 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0以及字符编码为UTF-8这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.exam.mapper.ExamRepoMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识这里对应着com.yf.exam.modules.exam.mapper.ExamRepoMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exam.modules.exam.entity.ExamRepo">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果准确地映射到指定的Java对象这里是ExamRepo类型。id属性为该结果映射的唯一标识符 -->
<id column="id" property="id" />
<!-- 定义主键的映射关系将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名property属性指定要映射到的Java对象中的属性名 -->
<result column="exam_id" property="examId" />
<!-- 把数据库表中的exam_id列的值映射到Java对象的examId属性 -->
<result column="repo_id" property="repoId" />
<!-- 将数据库表中的repo_id列的值映射到Java对象的repoId属性 -->
<result column="radio_count" property="radioCount" />
<!-- 映射数据库表中的radio_count列到Java对象的radioCount属性 -->
<result column="radio_score" property="radioScore" />
<!-- 把数据库表中的radio_score列的值映射到Java对象的radioScore属性 -->
<result column="multi_count" property="multiCount" />
<!-- 将数据库表中的multi_count列的值映射到Java对象的multiCount属性 -->
<result column="multi_score" property="multiScore" />
<!-- 把数据库表中的multi_score列的值映射到Java对象的multiScore属性 -->
<result column="judge_count" property="judgeCount" />
<!-- 将数据库表中的judge_count列的值映射到Java对象的judgeCount属性 -->
<result column="judge_score" property="judgeScore" />
<!-- 把数据库表中的judge_score列的值映射到Java对象的judgeScore属性 -->
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用这里列出了通用查询时要从数据库表中选择的列名使用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`exam_id`,`repo_id`,`radio_count`,`radio_score`,`multi_count`,`multi_score`,`judge_count`,`judge_score`
</sql>
<resultMap id="ExtResultMap" type="com.yf.exam.modules.exam.dto.ext.ExamRepoExtDTO" extends="BaseResultMap">
<!-- 定义一个名为ExtResultMap的结果映射它的类型是ExamRepoExtDTO并且通过extends属性继承了BaseResultMap意味着它会包含BaseResultMap中定义的所有映射关系在此基础上还可以添加新的映射关系 -->
<result column="totalRadio" property="totalRadio" />
<!-- 新增的映射关系将数据库表中的totalRadio列的值映射到Java对象的totalRadio属性 -->
<result column="totalMulti" property="totalMulti" />
<!-- 将数据库表中的totalMulti列的值映射到Java对象的totalMulti属性 -->
<result column="totalJudge" property="totalJudge" />
<!-- 把数据库表中的totalJudge列的值映射到Java对象的totalJudge属性 -->
</resultMap>
<select id="listByExam" resultMap="ExtResultMap">
<!-- 定义一个名为listByExam的查询语句其结果将按照ExtResultMap定义的映射关系进行映射 -->
SELECT ep.*,
(SELECT COUNT(0) FROM el_qu_repo WHERE repo_id=ep.repo_id AND qu_type=1) AS totalRadio,
<!-- 通过子查询计算出在el_qu_repo表中repo_id等于当前查询结果中的ep.repo_id且qu_type为1的记录数量并将其命名为totalRadio这个值将根据ExtResultMap的映射关系映射到对应的Java对象属性上 -->
(SELECT COUNT(0) FROM el_qu_repo WHERE repo_id=ep.repo_id AND qu_type=2) AS totalMulti,
<!-- 同样通过子查询计算出在el_qu_repo表中repo_id等于当前查询结果中的ep.repo_id且qu_type为2的记录数量并将其命名为totalMulti会根据映射关系映射到Java对象属性上 -->
(SELECT COUNT(0) FROM el_qu_repo WHERE repo_id=ep.repo_id AND qu_type=3) AS totalJudge
<!-- 再次通过子查询计算出在el_qu_repo表中repo_id等于当前查询结果中的ep.repo_id且qu_type为3的记录数量并将其命名为totalJudge也会按照映射关系映射到Java对象属性上 -->
FROM el_exam_repo ep
WHERE ep.exam_id=#{examId}
<!-- 添加WHERE子句条件筛选出在el_exam_repo表中exam_id等于传入的#{examId}参数值的记录 -->
</select>
</mapper>
</mapper>

@ -27,7 +27,113 @@
<sql id="Base_Column_List">
`id`,`user_id`,`depart_id`,`exam_id`,`title`,`total_time`,`user_time`,`total_score`,`qualify_score`,`obj_score`,`subj_score`,`user_score`,`has_saq`,`state`,`create_time`,`update_time`,`limit_time`
</sql>
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0以及字符编码为UTF-8这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.paper.mapper.PaperMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识这里对应着com.yf.exam.modules.paper.mapper.PaperMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exalModule paper.entity.Paper">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果准确地映射到指定的Java对象这里是Paper类型。id属性为该结果映射的唯一标识符 -->
<id column="id" property="id" />
<!-- 定义主键的映射关系将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名property属性指定要映射到的Java对象中的属性名 -->
<result column="user_id" property="userId" />
<!-- 把数据库表中的user_id列的值映射到Java对象的userId属性 -->
<result column="depart_id" property="departId" />
<!-- 将数据库表中的depart_id列的值映射到Java对象的departId属性 -->
<result column="exam_id" property="examId" />
<!-- 把数据库表中的exam_id列的值映射到Java对象的examId属性 -->
<result column="title" property="title" />
<!-- 将数据库表中的title列的值映射到Java对象的title属性 -->
<result column="total_time" property="totalTime" />
<!-- 把数据库表中的total_time列的值映射到Java对象的totalTime属性 -->
<result column="user_time" property="userTime" />
<!-- 将数据库表中的user_time列的值映射到Java对象的userTime属性 -->
<result column="total_score" property="totalScore" />
<!-- 把数据库表中的total_score列的值映射到Java对象的totalScore属性 -->
<result column="qualify_score" type="com.yf.exam.modules.paper.entity.Paper">
<!-- 将数据库表中的qualify_score列的值映射到Java对象的qualifyScore属性 -->
<id column="id" property="id" />
<result column="user_id" property="userId" />
<result column="depart_id" property="departId" />
<result column="exam_id" property="examId" />
<result column="title" property="title" />
<result column="total_time" property="totalTime" />
<result column="user_time" property="userTime" />
<result column="total_score" property="totalScore" />
<result column="qualify_score" property="qualifyScore" />
<result column="obj_score" property="objScore" />
<result column="subj_score" property="subjScore" />
<result column="user_score" property="userScore" />
<result column="has_saq" property="hasSaq" />
<result column="state" property="state" />
<result column="create_time" property="createTime" />
<result column="update_time" property="updateTime" />
<result column="limit_time" property="limitTime" />
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用这里列出了通用查询时要从数据库表中选择的列名使用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`user_id`,`depart_id`,`exam_id`,`title`,`total_time`,`user_time`,`total_score`,`qualify_score`,`obj_score`,`subj_score`,`user_score`,`has_saq`,`state`,`create_time`,`update_time`,`limit_time`
</sql>
<resultMap id="ListResultMap"
extends="BaseResultMap"
type="com.yf.exam.modules.paper.dto.response.PaperListRespDTO">
<!-- 定义一个名为ListResultMap的结果映射它通过extends属性继承了BaseResultMap意味着它会包含BaseResultMap中定义的所有映射关系在此基础上还可以添加新的映射关系。其类型是PaperListRespDTO -->
<result column="real_name" property="realName" />
<!-- 新增的映射关系将数据库表中的real_name列的值映射到Java对象的realName属性 -->
</resultMap>
<select id="paging" resultMap="ListResultMap">
<!-- 定义一个名为paging的查询语句其结果将按照ListResultMap定义的映射关系进行映射 -->
SELECT pp.*,uc.real_name FROM el_paper pp
LEFT JOIN sys_user uc ON pp.user_id=uc.id
<!-- 使用LEFT JOIN连接el_paper表和sys_user表连接条件是pp.user_id等于uc.id这样可以在查询结果中获取到与试卷相关用户的真实姓名 -->
<where>
<!-- <where>标签用于动态生成WHERE子句根据条件判断是否添加相应的条件语句 -->
<if test="query!=null">
<!-- <if>标签用于条件判断这里判断传入的参数query是否不为空 -->
<if test="query.examId!=null and query.examId!=''">
<!-- 进一步判断query对象中的examId属性是否不为空且不为空字符串如果满足条件则添加以下WHERE子句条件 -->
AND pp.exam_id=#{query.examId}
<!-- 将数据库表中的pp.exam_id列与传入的query.examId参数值进行精确匹配 -->
</if>
<if test="query.userId!=null and query.userId!=''">
<!-- 进一步判断query对象中的userId属性是否不为空且不为空字符串如果满足条件则添加以下WHERE子句条件 -->
AND pp.user_id=#{query.userId}
<!-- 将数据库表中的pp.user_id列与传入的query.userId参数值进行精确匹配 -->
</if>
<if test="query.departId!=null and query.departId!=''">
<!-- 进一步判断query对象中的departId属性是否不为空且不为空字符串如果满足条件则添加以下WHERE子句条件 -->
AND pp.departId=?
<!-- 将数据库表中的pp.depart_id列与传入的query.departId参数值进行精确匹配 -->
</if>
<if test="query.state!=null">
<!-- 进一步判断query对象中的state属性是否不为空如果满足条件则添加以下WHERE子句条件 -->
AND pp.state=#{query.state}
<!-- 将数据库表中的pp.state列与传入的query.state参数值进行精确匹配 -->
</if>
<if test="query.realName!=null and query.realName!=''">
<!-- 进一步判断query对象中的realName属性是否不为空且不为空字符串如果满足条件则添加以下WHERE子句条件 -->
AND uc.real_name LIKE CONCAT('%',#{query.realName},'%')
<!-- 使用LIKE关键字进行模糊查询将查询条件中的realName值与数据库表中的uc.real_name列进行模糊匹配#{query.realName}是MyBatis的参数占位符会被实际传入的参数值替换 -->
</if>
</if>
</where>
ORDER BY create_time DESC
<!-- 按照create_time列的值进行降序排序以便获取最新创建的记录排在前面 -->
</select>
</mapper>
<resultMap id="ListResultMap"
extends="BaseResultMap"

@ -1,46 +1,74 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0以及字符编码为UTF-8这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.paper.mapper.PaperQuAnswerMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识这里对应着com.yf.exam.modules.paper.mapper.PaperQuAnswerMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exam.modules.paper.entity.PaperQuAnswer">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果准确地映射到指定的Java对象这里是PaperQuAnswer类型。id属性为该结果映射的唯一标识符 -->
<id column="id" property="id" />
<!-- 定义主键的映射关系将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名property属性指定要映射到的Java对象中的属性名 -->
<result column="paper_id" property="paperId" />
<!-- 把数据库表中的paper_id列的值映射到Java对象的paperId属性 -->
<result column="answer_id" property="answerId" />
<!-- 将数据库表中的answer_id列的值映射到Java对象的answerId属性 -->
<result column="qu_id" property="quId" />
<!-- 把数据库表中的qu_id列的值映射到Java对象的quId属性 -->
<result column="is_right" property="isRight" />
<!-- 将数据库表中的is_right列的值映射到Java对象的isRight属性 -->
<result column="checked" property="checked" />
<!-- 把数据库表中的checked列的值映射到Java对象的checked属性 -->
<result column="sort" property="sort" />
<!-- 将数据库表中的sort列的值映射到Java对象的sort属性 -->
<result column="abc" property="abc" />
<!-- 把数据库表中的abc列的值映射到Java对象的abc属性 -->
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用这里列出了通用查询时要从数据库表中选择的列名使用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`paper_id`,`answer_id`,`qu_id`,`is_right`,`checked`,`sort`,`abc`
</sql>
<resultMap id="ListResultMap"
type="com.yf.exam.modules.paper.dto.ext.PaperQuAnswerExtDTO"
extends="BaseResultMap">
<!-- 定义一个名为ListResultMap的结果映射它的类型是PaperQuAnswerExtDTO并且通过extends属性继承了BaseResultMap意味着它会包含BaseResultMap中定义的所有映射关系在此基础上还可以添加新的映射关系 -->
<result column="image" property="image" />
<!-- 新增的映射关系将数据库表中的image列的值映射到Java对象的image属性 -->
<result column="content" property="content" />
<!-- 将数据库表中的content列的值映射到Java对象的content属性 -->
</resultMap>
<select id="list" resultMap="ListResultMap">
<!-- 定义一个名为list的查询语句其结果将按照ListResultMap定义的映射关系进行映射 -->
SELECT pa.`id`,pa.`paper_id`,pa.`answer_id`,pa.`qu_id`,pa.`checked`,pa.`sort`,pa.`abc`,qa.content,qa.image
<!-- 从el_paper_qu_answer表pa中选择指定列以及通过LEFT JOIN连接el_qu_answer表qa获取相关列的数据以便在查询结果中包含答案内容和图片等相关信息 -->
FROM el_paper_qu_answer pa
LEFT JOIN el_qu_answer qa ON pa.answer_id=qa.id
<!-- 使用LEFT JOIN连接el_paper_qu_answer表和el_qu_answer表连接条件是pa.answer_id等于qa.id这样可以获取到与试卷问题答案相关的完整信息 -->
WHERE pa.paper_id=#{paperId} AND pa.qu_id=#{quId}
<!-- 添加WHERE子句条件筛选出在el_paper_qu_answer表中paper_id等于传入的#{paperId}参数值且qu_id等于传入的#{quId}参数值的记录 -->
ORDER BY pa.sort ASC
<!-- 按照pa.sort列的值进行升序排序以便以特定顺序展示查询结果 -->
</select>
<select id="listForShow" resultMap="ListResultMap">
SELECT pa.`id`,pa.`paper_id`,pa.`answer_id`,pa.`qu_id`,pa.`checked`,pa.`sort`,pa.`abc`,qa.content,qa.is_right,qa.image
<!-- 定义一个名为listForShow的查询语句其结果将按照ListResultMap定义的映射关系进行映射 -->
SELECT pa.`id`,pa.`paper_id`,pa.`answer_id`,pa.`qu_id`,pa.`checked`,pa.`clock`,pa.`abc`,qa.content,qa.is_right,qa.image
<!-- 从el_paper_qu_answer表pa中选择指定列以及通过LEFT JOIN连接el_qu_answer表qa获取相关列的数据这里比上面的list查询多选择了qa.is_right列以便在查询结果中包含答案是否正确等相关信息 -->
FROM el_paper_qu_answer pa
LEFT JOIN el_qu_answer qa ON pa.answer_id=qa.id
<!-- 使用LEFT JOIN连接el_paper_qu_answer表和el_qu_answer表连接条件是pa.answer_id等于qa.id这样可以获取到与试卷问题答案相关的完整信息 -->
WHERE pa.paper_id=#{paperId} AND pa.qu_id=#{quId}
<!-- 添加WHERE子句条件筛选出在el_paper_qu_answer表中paper_id等于传入的#{paperId}参数值且qu_id等于传入的#{quId}参数值的记录 -->
ORDER BY pa.sort ASC
<!-- 按照pa.sort列的值进行升序排序以便以特定顺序展示查询结果 -->
</select>
</mapper>
</mapper>

@ -1,58 +1,93 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0以及字符编码为UTF-8这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.paper.mapper.PaperQuMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识这里对应着com.yf.exam.modules.paper.mapper.PaperQuMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exam.modules.paper.entity.PaperQu">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果准确地映射到指定的Java对象这里是PaperQu类型。id属性为该结果映射的唯一标识符 -->
<id column="id" property="id" />
<!-- 定义主键的映射关系将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名property属性指定要映射到的Java对象中的属性名 -->
<result column="paper_id" property="paperId" />
<!-- 把数据库表中的paper_id列的值映射到Java对象的paperId属性 -->
<result column="qu_id" property="quId" />
<!-- 将数据库表中的qu_id列的值映射到Java对象的quId属性 -->
<result column="qu_type" property="quType" />
<!-- 把数据库表中的qu_type列的值映射到Java对象的quType属性 -->
<result column="answered" property="answered" />
<!-- 将数据库表中的answered列的值映射到Java对象的answered属性 -->
<result column="answer" property="answer" />
<!-- 把数据库表中的answer列的值映射到Java对象的answer属性 -->
<result column="sort" property="sort" />
<!-- 将数据库表中的sort列的值映射到Java对象的sort属性 -->
<result column="score" property="score" />
<!-- 把数据库表中的score列的值映射到Java对象的score属性 -->
<result column="actual_score" property="actualScore" />
<!-- 将数据库表中的actual_score列的值映射到Java对象的actualScore属性 -->
<result column="is_right" property="isRight" />
<!-- 把数据库表中的is_right列的值映射到Java对象的isRight属性 -->
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用这里列出了通用查询时要从数据库表中选择的列名使用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`paper_id`,`qu_id`,`qu_type`,`answered`,`answer`,`sort`,`score`,`actual_score`,`is_right`
</sql>
<!-- 计算总分 -->
<select id="sumObjective" resultType="int">
SELECT IFNULL(SUM(actual_score),0) as total
FROM el_paper_qu
WHERE paper_id=#{paperId}
AND is_right=true
AND qu_type &lt; 4
</select>
<!-- 定义一个名为sumObjective的查询语句用于计算客观题的总分其结果类型为整数int -->
SELECT IFNULL(SUM(actual_score),0) as total
<!-- 使用IFNULL函数对SUM(actual_score)的结果进行处理如果SUM(actual_score)为NULL则返回0将结果命名为total -->
FROM el_paper_qu
<!-- 指定从el_paper_qu表中进行查询 -->
WHERE paper_id=#{paperId}
<!-- 添加WHERE子句条件筛选出在el_paper_qu表中paper_id等于传入的#{paperId}参数值的记录 -->
AND is_right=true
<!-- 进一步筛选出is_right列值为true的记录即只计算回答正确的客观题分数 -->
AND qu_type &lt; 4
<!-- 再筛选出qu_type列值小于4的记录通常用于区分客观题类型假设小于4代表客观题类型 -->
</select>
<select id="sumSubjective" resultType="int">
SELECT IFNULL(SUM(actual_score),0) as total
FROM el_paper_qu
WHERE paper_id=#{paperId}
AND qu_type=4
</select>
<!-- 定义一个名为sumSubjective的查询语句用于计算主观题的总分其结果类型为整数int -->
SELECT IFNULL(SUM(actual_score),0) as total
<!-- 使用IFNULL函数对SUM(actual_score)的结果进行处理如果SUM(actual_score)为NULL则返回0将结果命名为total -->
FROM el_paper_qu
<!-- 指定从el_paper_qu表中进行查询 -->
WHERE paper_id=#{paperId}
<!-- 添加WHERE子句条件筛选出在el_paper_qu表中paper_id等于传入的#{paperId}参数值的记录 -->
AND qu_type=4
<!-- 筛选出qu_type列值等于4的记录通常用于区分主观题类型假设等于4代表主观题类型 -->
</select>
<resultMap id="ListResultMap" extends="BaseResultMap" type="com.yf.exam.modules.paper.dto.ext.PaperQuDetailDTO">
<!-- 定义一个名为ListResultMap的结果映射它通过extends属性继承了BaseResultMap意味着它会包含BaseResultMap中定义的所有映射关系在此基础上还可以添加新的映射关系。其类型是PaperQuDetailDTO -->
<result column="image" property="image" />
<!-- 新增的映射关系将数据库表中的image列的值映射到Java对象的image属性 -->
<result column="content" property="content" />
<!-- 将数据库表中的content列的值映射到Java对象的content属性 -->
<collection property="answerList" column="{paperId=paper_id,quId=qu_id}"
select="com.yf.exam.modules.paper.mapper.PaperQuAnswerMapper.listForShow" />
<!-- 使用<collection>标签来处理一对多的关系这里表示将根据指定的条件paperId和quId从PaperQuAnswerMapper.listForShow查询中获取多条记录并将这些记录映射到Java对象的answerList属性上。column属性用于指定传递给子查询的参数select属性指定了要调用的子查询的Mapper方法 -->
</resultMap>
<select id="listByPaper" resultMap="ListResultMap">
<!-- 定义一个名为listByPaper的查询语句其结果将按照ListResultMap定义的映射关系进行映射 -->
SELECT pq.*,eq.content,eq.image
<!-- 从el_paper_qu表pq中选择所有列并通过LEFT JOIN连接el_qu表eq获取相关列content和image的数据以便在查询结果中包含题目内容和图片等相关信息 -->
FROM el_paper_qu pq
LEFT JOIN el_qu eq ON pq.qu_id = eq.id
<!-- 使用LEFT JOIN连接el_paper_qu表和el_qu表连接条件是pq.qu_id等于eq.id这样可以获取到与试卷题目相关的完整信息 -->
WHERE pq.paper_id=#{paperId}
<!-- 添加WHERE子句条件筛选出在el_paper_qu表中paper_id等于传入的#{paperId}参数值的记录 -->
ORDER BY pq.sort ASC
<!-- 按照pq.sort列的值进行升序排序以便以特定顺序展示查询结果 -->
</select>
</mapper>
</mapper>

@ -1,20 +1,33 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0以及字符编码为UTF-8这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.qu.mapper.QuAnswerMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识这里对应着com.yf.exam.modules.qu.mapper.QuAnswerMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exam.modules.qu.entity.QuAnswer">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果准确地快照到指定的Java对象这里是QuAnswer类型。id属性为该结果映射的唯一标识符 -->
<id column="id" property="id" />
<!-- 定义主键的映射关系将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名property属性指定要映射到的Java对象中的属性名 -->
<result column="qu_id" property="quId" />
<!-- 把数据库表中的qu_id列的值映射到Java对象的quId属性 -->
<result column="is_right" property="isRight" />
<!-- 将数据库表中的is_right列的值映射到Java对象的isRight属性 -->
<result column="image" property="image" />
<!-- 把数据库表中的image列的值映射到Java对象的image属性 -->
<result column="content" property="content" />
<!-- 将数据库表中的content列的值映射到Java对象的content属性 -->
<result column="analysis" property="analysis" />
<!-- 把数据库表中的analysis列的值映射到Java对象的analysis属性 -->
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用这里列出了通用查询时要从数据库表中选择的列名使用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`qu_id`,`is_right`,`image`,`content`,`analysis`
</sql>
</mapper>
</mapper>

@ -1,90 +1,145 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0以及字符编码为UTF-8这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.qu.mapper.QuMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识这里对应着com.yf.exam.modules.qu.mapper.QuMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exam.modules.qu.entity.Qu">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果准确地映射到指定的Java对象这里是Qu类型。id属性为该结果映射的唯一标识符 -->
<id column="id" property="id" />
<!-- 定义主键的映射关系将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名property属性指定要映射到的Java对象中的属性名 -->
<result column="qu_type" property="quType" />
<!-- 把数据库表中的qu_type列的值映射到Java对象的quType属性 -->
<result column="level" property="level" />
<!-- 将数据库表中的level列的值映射到Java对象的level属性 -->
<result column="image" property="image" />
<!-- 把数据库表中的image列的值映射到Java对象的image属性 -->
<result column="content" property="content" />
<!-- 将数据库表中的content列的值映射到Java对象的content属性 -->
<result column="create_time" property="createTime" />
<!-- 把数据库表中的create_time列的值映射到Java对象的createTime属性 -->
<result column="update_time" property="updateTime" />
<!-- 将数据库表中的update_time列的值映射到Java对象的updateTime属性 -->
<result column="remark" property="remark" />
<!-- 把数据库表中的remark列的值映射到Java对象的remark属性 -->
<result column="analysis" property="analysis" />
</resultMap>
<!-- 将数据库表中的analysis列的值映射到Java对象的analysis属性 -->
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用这里列出了通用查询时要从数据库表中选择的列名使用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`qu_type`,`level`,`image`,`content`,`create_time`,`update_time`,`remark`,`analysis`
</sql>
<!-- 随机取数据 -->
<select id="listByRandom" resultMap="BaseResultMap">
<!-- 定义一个名为listByRandom的查询语句其结果将按照BaseResultMap定义的映射关系进行映射 -->
SELECT a.*
<!-- 选择el_qu表a中的所有列数据 -->
FROM el_qu a
LEFT JOIN el_qu_repo b ON a.id=b.qu_id
<!-- 使用LEFT JOIN连接el_qu表a和el_qu_repo表b连接条件是a.id等于b.qu_id这样可以关联题目el_qu表和题目资源库el_qu_repo表的相关信息 -->
WHERE b.repo_id=#{repoId} AND a.qu_type=#{quType}
<!-- 添加WHERE子句条件筛选出在el_qu_repo表中repo_id等于传入的#{repoId}参数值且在el_qu表中qu_type等于传入的#{quType}参数值的记录 -->
<if test="excludes!=null">
<!-- <if>标签用于条件判断这里判断传入的参数excludes是否不为空 -->
AND a.id NOT IN
<!-- 当excludes不为空时添加条件使得查询结果中的a.id不在excludes所包含的列表值中 -->
<foreach item="item" collection="excludes" separator="," open="(" close=")" index="">'${item}'</foreach>
<!-- 使用<foreach>标签遍历excludes集合将集合中的每个元素这里用'${item}'表示,注意这里是使用$符号进行字符串拼接可能存在SQL注入风险要确保数据来源可靠作为一个值放在IN子句中open、close、separator分别指定了括号的开头、结尾和元素之间的分隔符 -->
</if>
ORDER BY RAND()
<!-- 按照随机顺序对查询结果进行排序,使得每次查询结果的顺序是随机的 -->
LIMIT ${size}
<!-- 限制查询结果的数量为传入的${size}参数值,同样这里使用$符号进行参数替换,要注意数据来源的安全性 -->
</select>
<resultMap id="ExportResultMap" type="com.yf.exam.modules.qu.dto.export.QuExportDTO">
<!-- 定义一个名为ExportResultMap的结果映射它的类型是QuExportDTO用于将数据库查询结果映射到特定的用于导出的DTO对象 -->
<id column="q_id" property="qId" />
<!-- 定义主键的映射关系将数据库表中的q_id列的值映射到Java对象的qId属性上 -->
<result column="qu_type" property="quType" />
<!-- 把数据库表中的qu_type列的值映射到Java对象的quType属性 -->
<result column="q_content" property="qContent" />
<!-- 将数据库表中的q_content列的值映射到Java对象的qContent属性 -->
<result column="q_analysis" property="qAnalysis" />
<!-- 把数据库表中的q_analysis列的值映射到Java对象的qAnalysis属性 -->
<result column="a_is_right" property="aIsRight" />
<!-- 将数据库表中的a_is_right列的值映射到Java对象的aIsRight属性 -->
<result column="a_content" property="aContent" />
<!-- 把数据库表中的a_content列的值映射到Java对象的aContent属性 -->
<result column="a_analysis" property="aAnalysis" />
<!-- 将数据库表中的a_analysis列的值映射到Java对象的aAnalysis属性 -->
<collection property="repoList" column="q_id" select="selectRepos"/>
<!-- 使用<collection>标签来处理一对多的关系这里表示将根据q_id列的值从selectRepos查询中获取多条记录并将这些记录映射到Java对象的repoList属性上。column属性用于指定传递给子查询的参数select属性指定了要调用的子查询的方法名这里对应下面定义的selectRepos查询 -->
</resultMap>
<select id="selectRepos" resultType="String">
SELECT repo_id FROM el_qu_repo po WHERE po.qu_id=#{qId}
</select>
<!-- 定义一个名为selectRepos的查询语句其结果类型为字符串String用于查询与特定题目由qId指定相关的资源库ID -->
SELECT repo_id FROM el_qu_repo po WHERE po.qu_id=#{qId}
<!-- 从el_qu_repo表po中选择repo_id列筛选条件是po.qu_id等于传入的#{qId}参数值 -->
</select>
<sql id="query">
<!-- 定义一个名为query的SQL片段可在其他SQL语句中引用用于构建动态查询条件 -->
<where>
<!-- <where>标签用于动态生成WHERE子句根据条件判断是否添加相应的条件语句 -->
<if test="query!=null">
<!-- <if>标签用于条件判断这里判断传入的参数query是否不为空 -->
<if test="query.quType!=null">
<!-- 进一步判断query对象中的quType属性是否不为空如果满足条件则添加以下WHERE子句条件 -->
AND q.qu_type = #{query.quType}
<!-- 将数据库表中的q.qu_type列与传入的query.quType参数值进行精确匹配 -->
</if>
<if test="query.repoIds!=null and query.repoIds.size()>0">
<!-- 进一步判断query对象中的repoIds属性是否不为空且集合大小大于0如果满足条件则添加以下WHERE子句条件 -->
AND po.repo_id IN
<!-- 使用IN子句将po.repo_id列的值与query.repoIds集合中的元素进行匹配 -->
<foreach collection="query.repoIds" open="(" close=")" separator="," item="repoId">#{repoId}</foreach>
<!-- 使用<foreach>标签遍历query.repoIds集合将集合中的每个元素这里用#{repoId}表示,通过#符号进行参数替换相对安全作为一个值放在IN子句中open、close、separator分别指定了括号的开头、结尾和元素之间的分隔符 -->
</if>
<if test="query.content!=null and query.content!=''">
<!-- 进一步判断query对象中的content属性是否不为空且不为空字符串如果满足条件则添加以下WHERE子句条件 -->
AND q.content LIKE CONCAT('%',#{query.content},'%')
<!-- 使用LIKE关键字进行模糊查询将查询条件中的content值与数据库表中的q.content列进行模糊匹配#{query.content}是MyBatis的参数占位符会被实际传入的参数值替换 -->
</if>
<if test="query.excludes!=null and query.excludes.size()>0">
<!-- 进一步判断query对象中的excludes属性是否不为空且集合大小大于0如果满足条件则添加以下WHERE子句条件 -->
AND q.id NOT IN
<!-- 添加条件使得查询结果中的q.id不在query.excludes所包含的列表值中 -->
<foreach collection="query.excludes" open="(" close=")" separator="," item="quId">
#{quId}
</foreach>
<!-- 使用<foreach>标签遍历query.excludes集合将集合中的每个元素这里用#{quId}表示,通过#符号进行参数替换相对安全作为一个值放在NOT IN子句中open、close、separator分别指定了括号的开头、结尾和元素之间的分隔符 -->
</if>
</if>
</where>
</sql>
<select id="paging" resultMap="BaseResultMap">
<!-- 定义一个名为paging的查询语句其结果将按照BaseResultMap定义的映射关系进行映射 -->
SELECT q.*
<!-- 选择el_qu表q中的所有列数据 -->
FROM el_qu q
LEFT JOIN el_qu_repo po ON q.id=po.qu_id
<!-- 使用LEFT JOIN连接el_qu表q和el_qu_repo表po连接条件是q.id等于po.qu_id这样可以关联题目el_qu表和题目资源库el_qu_repo表的相关信息 -->
<include refid="query" />
<!-- 引用上面定义的query SQL片段将其包含的动态查询条件添加到当前查询语句中 -->
GROUP BY q.id ORDER BY q.update_time DESC
<!-- 按照q.id进行分组然后按照q.update_time列的值进行降序排序以便获取最新更新的记录排在前面 -->
</select>
<select id="listForExport" resultMap="ExportResultMap">
<!-- 定义一个名为listForExport的查询语句其结果将按照ExportResultMap定义的映射关系进行映射 -->
SELECT
q.id as q_id,
q.qu_type,
@ -93,12 +148,17 @@
a.content as a_content,
a.is_right as a_is_right,
a.analysis as a_analysis
<!-- 从el_qu表q和el_qu_answer表a中选择指定列的数据同时对某些列进行别名设置以便在结果映射时能准确对应到ExportResultMap中定义的属性 -->
FROM el_qu q
LEFT JOIN el_qu_answer a ON q.id=a.qu_id
LEFT JOIN el_qu_repo po ON q.id=po.qu_id
<!-- 使用LEFT JOIN连接el_qu表q、el_qu_answer表a和el_qu_repo表po连接条件分别是q.id等于a.qu_id和q.id等于po.qu_id这样可以关联题目、题目答案以及题目资源库的相关信息 -->
<include refid="query" />
<!-- 引用上面定义的query SQL片段将其包含的动态查询条件添加到当前查询语句中 -->
GROUP BY a.id ORDER BY q.id
<!-- 按照a.id进行分组然后按照q.id列的值进行排序以便以特定顺序展示查询结果 -->
LIMIT 10000
<!-- 限制查询结果的数量为10000条 -->
</select>
</mapper>
</mapper>

@ -1,20 +1,32 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0以及字符编码为UTF-8这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.qu.mapper.QuRepoMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识这里对应着com.yf.exam.modules.qu.mapper.QuRepoMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exam.modules.qu.entity.QuRepo">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果准确地映射到指定的Java对象这里是QuRepo类型。id属性为该结果映射的唯一标识符 -->
<id column="id" property="id" />
<!-- 定义主键的映射关系将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名property属性指定要映射到的Java对象中的属性名 -->
<result column="qu_id" property="quId" />
<!-- 把数据库表中的qu_id列的值映射到Java对象的quId属性 -->
<result column="repo_id" property="repoId" />
<!-- 将数据库表中的repo_id列的值映射到Java对象的repoId属性 -->
<result column="qu_type" property="quType" />
<!-- 把数据库表中的qu_type列的值映射到Java对象的quType属性 -->
<result column="sort" property="sort" />
</resultMap>
<!-- 将数据库表中的sort列的值映射到Java对象的sort属性 -->
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用这里列出了通用查询时要从数据库表中选择的列名使用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`qu_id`,`repo_id`,`qu_type`,`sort`
</sql>
</mapper>
</mapper>

@ -1,19 +1,32 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0以及字符编码为UTF-8这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.repo.mapper.RepoMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识这里对应着com.yf.exam.modules.repo.mapper.RepoMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exam.modules.repo.entity.Repo">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果准确地映射到指定的Java对象这里是Repo类型。id属性为该结果映射的唯一标识符 -->
<id column="id" property="id" />
<!-- 定义主键的映射关系将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名property属性指定要映射到的Java对象中的属性名 -->
<result column="code" property="code" />
<!-- 把数据库表中的code列的值映射到Java对象的code属性 -->
<result column="title" property="title" />
<!-- 将数据库表中的title列的值映射到Java对象的title属性 -->
<result column="remark" property="remark" />
<!-- 把数据库表中的remark列的值映射到Java对象的remark属性 -->
<result column="create_time" property="createTime" />
<!-- 将数据库表中的create_time列的值映射到Java对象的createTime属性 -->
<result column="update_time" property="updateTime" />
</resultMap>
<!-- 把数据库表中的update_time列的值映射到Java对象的updateTime属性 -->
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用这里列出了通用查询时要从数据库表中选择的列名使用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`code`,`title`,`radio_count`,`multi_count`,`judge_count`,`remark`,`create_time`,`update_time`
</sql>
@ -21,25 +34,40 @@
<resultMap id="ListResultMap"
type="com.yf.exam.modules.repo.dto.response.RepoRespDTO"
extends="BaseResultMap">
<!-- 定义一个名为ListResultMap的结果映射它的类型是RepoRespDTO并且通过extends属性继承了BaseResultMap意味着它会包含BaseResultMap中定义的所有映射关系在此基础上还可以添加新的映射关系 -->
<result column="radio_count" property="radioCount" />
<!-- 新增的映射关系将数据库表中的radio_count列的值映射到Java对象的radioCount属性 -->
<result column="multi_count" property="multiCount" />
<!-- 将数据库表中的multi_count列的值映射到Java对象的multiCount属性 -->
<result column="judge_count" property="judgeCount" />
</resultMap>
<!-- 把数据库表中的judge_count列的值映射到Java对象的judgeCount属性 -->
</resultMap>
<select id="paging" resultMap="ListResultMap">
<!-- 定义一个名为paging的查询语句其结果将按照ListResultMap定义的映射关系进行映射 -->
SELECT `id`, `code`, `title`, `remark`, `create_time`, `update_time`,
(SELECT COUNT(0) FROM el_qu_repo WHERE repo_id=repo.id AND qu_type=1) AS radio_count,
<!-- 通过子查询计算出在el_qu_repo表中repo_id等于当前查询结果中的repo.id且qu_type为1的记录数量并将其命名为radio_count这个值将根据ListResultMap的映射关系映射到对应的Java对象属性上 -->
(SELECT COUNT(0) FROM el_qu_repo WHERE repo_id=repo.id AND qu_type=2) AS multi_count,
<!-- 同样通过子查询计算出在el_qu_repo表中repo_id等于当前查询结果中的repo.id且qu_type为2的记录数量并将其命名为multi_count会根据映射关系映射到Java对象属性上 -->
(SELECT COUNT(0) FROM el_qu_repo WHERE repo_id=repo.id AND qu_type=3) AS judge_count
<!-- 再次通过子查询计算出在el_qu_repo表中repo_id等于当前查询结果中的repo.id且qu_type为3的记录数量并将其命名为judge_count也会按照映射关系映射到Java对象属性上 -->
FROM el_repo repo
<where>
<!-- <where>标签用于动态生成WHERE子句根据条件判断是否添加相应的条件语句 -->
<if test="query!=null">
<!-- <if>标签用于条件判断这里判断传入的参数query是否不为空 -->
<if test="query.title!=null and query.title!=''">
<!-- 进一步判断query对象中的title属性是否不为空且不为空字符串如果满足条件则添加以下WHERE子句条件 -->
AND repo.title LIKE CONCAT('%',#{query.title}, '%')
<!-- 使用LIKE关键字进行模糊查询将查询条件中的title值与数据库表中的repo.title列进行模糊匹配#{query.title}是MyBatis的参数占位符会被实际传入的参数值替换 -->
</if>
<if test="query.excludes!=null and query.excludes.size()>0">
<!-- 进一步判断query对象中的excludes属性是否不为空且集合大小大于0如果满足条件则添加以下WHERE子句条件 -->
AND repo.id NOT IN
<!-- 添加条件使得查询结果中的repo.id不在query.excludes所包含的列表值中 -->
<foreach collection="query.excludes" open="(" close=")" separator="," item="id">
<!-- 使用<foreach>标签遍历query.excludes集合将集合中的每个元素这里用#{id}表示,通过#符号进行参数替换相对安全作为一个值放在NOT IN子句中open、close、separator分别指定了括号的开头、结尾和元素之间的分隔符 -->
#{id}
</foreach>
</if>
@ -48,4 +76,4 @@
</select>
</mapper>
</mapper>

@ -1,19 +1,32 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0以及字符编码为UTF-8这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.sys.depart.mapper.SysDepartMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识这里对应着com.yf.exam.modules.sys.depart.mapper.SysDepartMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exam.modules.sys.depart.entity.SysDepart">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果准确地映射到指定的Java对象这里是SysDepart类型。id属性为该结果映射的唯一标识符 -->
<id column="id" property="id" />
<!-- 定义主键的映射关系将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名property属性指定要映射到的Java对象中的属性名 -->
<result column="dept_type" property="deptType" />
<!-- 把数据库表中的dept_type列的值映射到Java对象的deptType属性 -->
<result column="parent_id" property="parentId" />
<!-- 将数据库表中的parent_id列的值映射到Java对象的parentId属性 -->
<result column="dept_name" property="deptName" />
<!-- 把数据库表中的dept_name列的值映射到Java对象的deptName属性 -->
<result column="dept_code" property="deptCode" />
<!-- 将数据库表中的dept_code列的值映射到Java对象的deptCode属性 -->
<result column="sort" property="sort" />
</resultMap>
<!-- 把数据库表中的sort列的值映射到Java对象的sort属性 -->
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用这里列出了通用查询时要从数据库表中选择的列名使用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`dept_type`,`parent_id`,`dept_name`,`dept_code`,`sort`
</sql>
@ -21,20 +34,29 @@
<resultMap id="TreeResultMap"
type="com.yf.exam.modules.sys.depart.dto.response.SysDepartTreeDTO"
extends="BaseResultMap">
<!-- 定义一个名为TreeResultMap的结果映射它的类型是SysDepartTreeDTO并且通过extends属性继承了BaseResultMap意味着它会包含BaseResultMap中定义的所有映射关系在此基础上还可以添加新的映射关系 -->
<collection property="children" column="id" select="findChildren"></collection>
<!-- 使用<collection>标签来处理一对多的关系这里表示将根据id列的值从findChildren查询中获取多条记录并将这些记录映射到Java对象的children属性上。column属性用于指定传递给子查询的参数select属性指定了要调用的子查询的方法名这里对应下面定义的findChildren查询 -->
</resultMap>
<select id="findChildren" resultMap="TreeResultMap">
<!-- 定义一个名为findChildren的查询语句其结果将按照TreeResultMap定义的映射关系进行映射 -->
SELECT * FROM sys_depart WHERE parent_id=#{id}
<!-- 从sys_depart表中选择所有列的数据筛选条件是parent_id等于传入的#{id}参数值,用于获取指定父节点(由#{id}确定)下的所有子部门信息 -->
</select>
<select id="paging" resultMap="TreeResultMap">
<!-- 定义一个名为paging的查询语句其结果将按照TreeResultMap定义的映射关系进行映射 -->
SELECT * FROM sys_depart WHERE parent_id='0'
<!-- 从sys_depart表中选择所有列的数据筛选条件是parent_id等于'0'通常用于获取顶级部门假设parent_id为'0'表示顶级部门)的信息 -->
<if test="query!=null">
<!-- <if>标签用于条件判断这里判断传入的参数query是否不为空 -->
<if test="query.deptName!=null and query.deptName!=''">
<!-- 进一步判断query对象中的deptName属性是否不为空且不为空字符串如果满足条件则添加以下WHERE子句条件 -->
AND dept_name LIKE CONCAT('%',#{query.deptName},'%')
<!-- 使用LIKE关键字进行模糊查询将查询条件中的deptName值与数据库表中的dept_name列进行模糊匹配#{query.deptName}是MyBatis的参数占位符会被实际传入的参数值替换 -->
</if>
</if>
</select>
</mapper>
</mapper>

@ -1,9 +1,22 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0以及字符编码为UTF-8这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.sys.system.mapper.SysDictMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一的标识这里对应着com.yf.exam.modules.sys.system.mapper.SysDictMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<select id="findDict" resultType="String">
<!-- 定义一个名为findDict的查询语句其结果类型为字符串String意味着该查询将返回一个字符串类型的结果 -->
SELECT ${text} FROM ${table} WHERE ${key}=${value} LIMIT 1
<!-- 这是一个简单的SQL查询语句其中使用了动态参数${text}、${table}、${key}、${value})。
SELECT后面跟着的${text}表示要从数据库表中选择的列名,这个列名是通过外部传入的参数动态确定的。
FROM后面跟着的${table}表示要查询的数据库表名,同样是通过外部传入的参数来指定。
WHERE后面跟着的${key}=${value}表示查询的条件,即根据传入的键(${key})和对应的值(${value})来筛选符合条件的记录。
LIMIT 1表示只获取满足条件的第一条记录用于获取特定条件下的单个结果。
需要注意的是,这里使用${}来引用参数的方式存在一定的SQL注入风险因为外部传入的参数如果被恶意构造可能会改变原本预期的SQL语句结构导致安全问题。在实际应用中应尽量使用#{}来引用参数它会对传入的参数进行预编译处理能有效防止SQL注入攻击。 -->
</select>
</mapper>
</mapper>

@ -1,16 +1,25 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0以及字符编码为UTF-8这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.sys.user.mapper.SysRoleMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识这里对应着com.yf.exam.modules.sys.user.mapper.SysRoleMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exam.modules.sys.user.entity.SysRole">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果准确地映射到指定的Java对象这里是SysRole类型。id属性为该结果映射的唯一标识符 -->
<id column="id" property="id" />
<!-- 定义主键的映射关系将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名property属性指定要映射到的Java对象中的属性名 -->
<result column="role_name" property="roleName" />
</resultMap>
<!-- 把数据库表中的role_name列的值映射到Java对象的roleName属性 -->
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用这里列出了通用查询时要从数据库表中选择的列名使用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`role_name`
</sql>
</mapper>
</mapper>

@ -1,24 +1,41 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0以及字符编码为UTF-8这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.sys.user.mapper.SysUserMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识这里对应着com.yf.exam.modules.sys.user.mapper.SysUserMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exam.modules.sys.user.entity.SysUser">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果准确地映射到指定的Java对象这里是SysUser类型。id属性为该结果映射的唯一标识符 -->
<id column="id" property="id" />
<!-- 定义主键的映射关系将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名property属性指定要映射到的Java对象中的属性名 -->
<result column="user_name" property="userName" />
<!-- 把数据库表中的user_name列的值映射到Java对象的userName属性 -->
<result column="real_name" property="realName" />
<!-- 将数据库表中的real_name列的值映射到Java对象的realName属性 -->
<result column="password" property="password" />
<!-- 把数据库表中的password列的值映射到Java对象的password属性 -->
<result column="salt" property="salt" />
<!-- 将数据库表中的salt列的值映射到Java对象的salt属性 -->
<result column="role_ids" property="roleIds" />
<!-- 把数据库表中的role_ids列的值映射到Java对象的roleIds属性 -->
<result column="depart_id" property="departId" />
<!-- 将数据库表中的depart_id列的值映射到Java对象的departId属性 -->
<result column="create_time" property="createTime" />
<!-- 把数据库表中的create_time列的值映射到Java对象的createTime属性 -->
<result column="update_time" property="updateTime" />
<!-- 将数据库表中的update_time列的值映射到Java对象的updateTime属性 -->
<result column="state" property="state" />
</resultMap>
<!-- 把数据库表中的state列的值映射到Java对象的state属性 -->
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用这里列出了通用查询时要从数据库表中选择的列名使用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`user_name`,`real_name`,`password`,`salt`,`role_ids`,`depart_id`,`create_time`,`update_time`,`state`
</sql>
</mapper>
</mapper>

@ -1,17 +1,27 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0以及字符编码为UTF-8这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.sys.user.mapper.SysUserRoleMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识这里对应着com.yf.exam.modules.sys.user.mapper.SysUserRoleMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exam.modules.sys.user.entity.SysUserRole">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果准确地映射到指定的Java对象这里是SysUserRole类型。id属性为该结果映射的唯一标识符 -->
<id column="id" property="id" />
<!-- 定义主键的映射关系将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名property属性指定要映射到的Java对象中的属性名 -->
<result column="user_id" property="userId" />
<!-- 把数据库表中的user_id列的值映射到Java对象的userId属性 -->
<result column="role_id" property="roleId" />
</resultMap>
<!-- 将数据库表中的role_id列的值映射到Java对象的roleId属性 -->
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用这里列出了通用查询时要从数据库表中选择的列名使用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`user_id`,`role_id`
</sql>
</mapper>
</mapper>

@ -1,23 +1,39 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0以及字符编码为UTF-8这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.user.book.mapper.UserBookMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识这里对应着com.yf.exam.modules.user.book.mapper.UserBookMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exam.modules.user.book.entity.UserBook">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果准确地映射到指定的Java对象这里是UserBook类型。id属性为该结果映射的唯一标识符 -->
<id column="id" property="id" />
<!-- 定义主键的映射关系将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名property属性指定要映射到的Java对象中的属性名 -->
<result column="exam_id" property="examId" />
<!-- 把数据库表中的exam_id列的值映射到Java对象的examId属性 -->
<result column="user_id" property="userId" />
<!-- 将数据库表中的user_id列的值映射到Java对象的userId属性 -->
<result column="qu_id" property="quId" />
<!-- 把数据库表中的qu_id列的值映射到Java对象的quId属性 -->
<result column="create_time" property="createTime" />
<!-- 将数据库表中的create_time列的值映射到Java对象的createTime属性 -->
<result column="update_time" property="updateTime" />
<!-- 把数据库表中的update_time列的值映射到Java对象的updateTime属性 -->
<result column="wrong_count" property="wrongCount" />
<!-- 将数据库表中的wrong_count列的值映射到Java对象的wrongCount属性 -->
<result column="title" property="title" />
<!-- 把数据库表中的title列的值映射到Java对象的title属性 -->
<result column="sort" property="sort" />
</resultMap>
<!-- 将数据库表中的sort列的值映射到Java对象的sort属性 -->
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用这里列出了通用查询时要从数据库表中选择的列名使用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`exam_id`,`user_id`,`qu_id`,`create_time`,`update_time`,`wrong_count`,`title`,`sort`
</sql>
</mapper>
</mapper>

@ -1,21 +1,36 @@
<?xml version="1.0" encoding="UTF-8"?>
<!-- XML声明指定了XML的版本为1.0以及字符编码为UTF-8这是告诉XML解析器如何正确解析该XML文件的基础信息 -->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- 文档类型定义DOCTYPE声明表明此XML文档遵循MyBatis的Mapper 3.0的文档类型定义DTD规范同时给出了DTD文件的网络地址以便解析器能依据该DTD验证XML文档结构的正确性 -->
<mapper namespace="com.yf.exam.modules.user.exam.mapper.UserExamMapper">
<!-- 定义了一个MyBatis的Mappernamespace属性指定了该Mapper在整个项目中的唯一标识这里对应着com.yf.exam.modules.user.exam.mapper.UserExamMapper接口用于将XML中的SQL语句与对应的Java接口方法关联起来 -->
<!-- 通用查询映射结果 -->
<resultMap id="BaseResultMap" type="com.yf.exam.modules.user.exam.entity.UserExam">
<!-- 开始定义一个名为BaseResultMap的结果映射用于将数据库查询结果准确地映射到指定的Java对象这里是UserExam类型。id属性为该结果映射的唯一标识符 -->
<id column="id" property="id" />
<!-- 定义主键的映射关系将数据库表中的id列的值映射到Java对象的id属性上。column属性指定数据库表中的列名property属性指定要映射到的Java对象中的属性名 -->
<result column="user_id" property="userId" />
<!-- 把数据库表中的user_id列的值映射到Java对象的userId属性 -->
<result column="exam_id" property="examId" />
<!-- 将数据库表中的exam_id列的值映射到Java对象的examId属性 -->
<result column="try_count" property="tryCount" />
<!-- 把数据库表中的try_count列的值映射到Java对象的tryCount属性 -->
<result column="max_score" property="maxScore" />
<!-- 将数据库表中的max_score列的值映射到Java对象的maxScore属性 -->
<result column="passed" property="passed" />
<!-- 把数据库表中的passed列的值映射到Java对象的passed属性 -->
<result column="create_time" property="createTime" />
<!-- 将数据库表中的create_time列的值映射到Java对象的createTime属性 -->
<result column="update_time" property="updateTime" />
</resultMap>
<!-- 把数据库表中的update_time列的值映射到Java对象的updateTime属性 -->
</resultMap>
<!-- 通用查询结果列 -->
<sql id="Base_Column_List">
<!-- 定义了一个名为Base_Column_List的SQL片段可在其他SQL语句中引用这里列出了通用查询时要从数据库表中选择的列名使用反引号`括起来是为了防止列名是SQL关键字时出现语法错误 -->
`id`,`user_id`,`exam_id`,`try_count`,`max_score`,`passed`,`create_time`,`update_time`
</sql>
@ -23,32 +38,46 @@
<resultMap id="ListResultMap"
type="com.yf.exam.modules.user.exam.dto.response.UserExamRespDTO"
extends="BaseResultMap">
<!-- 定义一个名为ListResultMap的结果映射它的类型是UserExamRespDTO并且通过extends属性继承了BaseResultMap意味着它会包含BaseResultMap中定义的所有映射关系在此基础上还可以添加新的映射关系 -->
<result column="title" property="title" />
<!-- 新增的映射关系将数据库表中的title列的值映射到Java对象的title属性 -->
<result column="real_name" property="realName" />
</resultMap>
<!-- 将数据库表中的real_name列的值映射到Java对象的realName属性 -->
</resultMap>
<select id="paging" resultMap="ListResultMap">
<!-- 定义一个名为paging的查询语句其结果将按照ListResultMap定义的映射关系进行映射 -->
SELECT ue.*,ee.title,uc.real_name FROM el_user_exam ue
LEFT JOIN el_exam ee ON ue.exam_id=ee.id
LEFT JOIN sys_user uc ON ue.user_id=uc.id
<!-- 使用LEFT JOIN连接el_user_exam表ue、el_exam表ee和sys_user表uc分别通过ue.exam_id=ee.id和ue.user_id=uc.id建立连接条件以便在查询结果中获取到与用户考试相关的考试信息如考试标题以及用户的真实姓名等信息 -->
WHERE ee.id IS NOT NULL AND uc.id IS NOT NULL
<!-- 添加WHERE子句条件筛选出在el_exam表和sys_user表中对应的id不为空的记录确保连接后的数据是有效的 -->
<if test="query!=null">
<!-- <if>标签用于条件判断这里判断传入的参数query是否不为空 -->
<if test="query.userId!=null and query.userId!=''">
<!-- 进一步判断query对象中的userId属性是否不为空且不为空字符串如果满足条件则添加以下WHERE子句条件 -->
AND ue.user_id='{{userId}}'
<!-- 将数据库表中的ue.user_id列与传入的query.userId参数值这里使用{{userId}}这种格式可能不太常见,通常应该是#{query.userId}这种MyBatis的参数占位符格式需要确认一下是否正确进行精确匹配 -->
</if>
<if test="query.examId!=null and query.examId!=''">
<!-- 进一步判断query对象中的examId属性是否不为空且不为空字符串如果满足条件则添加以下WHERE子句条件 -->
AND ue.exam_id = #{query.examId}
<!-- 将数据库表中的ue.exam_id列与传入的query.examId参数值进行精确匹配这里使用了正确的MyBatis参数占位符格式 -->
</if>
<if test="query.title!=null and query.title!=''">
<!-- 进一步判断query对象中的title属性是否不为空且不为空字符串如果满足条件则添加以下WHERE子句条件 -->
AND ee.title LIKE CONCAT('%',#{query.title},'%')
<!-- 使用LIKE关键字进行模糊查询将查询条件中的title值与数据库表中的ee.title列进行模糊匹配#{query.title}是MyBatis的参数占位符会被实际传入的参数值替换 -->
</if>
<if test="query.realName!=null and query.realName!=''">
<!-- 进一步判断query对象中的realName属性是否不为空且不为空字符串如果满足条件则添加以下WHERE子句条件 -->
AND uc.real_name LIKE CONCAT('%',#{query.realName},'%')
<!-- 使用LIKE关键字进行模糊查询将查询条件中的realName值与数据库表中的uc.real_name列进行模糊匹配#{query.realName}是MyBatis的参数占位符会被实际传入的参数值替换 -->
</if>
</if>
</select>
</mapper>
</mapper>
Loading…
Cancel
Save