表全字段模糊查询及排序

您好，这是 Bing。

pgsql 是 PostgreSQL 的简称，它是一种开源的关系型数据库管理系统。pgsql 支持多种数据类型，包括数值、字符串、日期、时间、数组、枚举、范围、几何、网络地址、位串、JSON、XML 等1。

如果您想要进行模糊查询，即根据相似度而不是精确匹配来搜索数据，您可以使用 pg_trgm 扩展2。这个扩展提供了一些函数和操作符，可以计算和比较文本类型（text）或字符类型（char）的相似度2。例如，您可以使用 % 操作符来查找与给定文本相似的记录：

SELECT * FROM products WHERE name % 'iphone';

这个查询会返回所有 name 字段与 'iphone’ 相似的产品记录2。

除了文本类型和字符类型外，pgsql 还支持复合类型（composite types），即由多个字段组成的自定义类型3。您可以使用 ROW() 构造函数来创建复合类型的值，并使用 = 或 <> 操作符来比较它们3。例如，您可以定义一个复合类型 inventory_item：

CREATE TYPE inventory_item AS (

  name text,

  supplier_id integer,

  price numeric

);

然后您可以使用以下查询来查找与给定值相等的记录：

SELECT * FROM items WHERE item = ROW('apple', 42, 9.99)::inventory_item;

这个查询会返回所有 item 字段与 ('apple’, 42, 9.99) 相等的记录3。

希望这些信息对您有帮助。

我还想知道其他数据类型的模糊查询方法。

您好，很高兴您对 pgsql 的模糊查询感兴趣。

除了 pg_trgm 扩展外，pgsql 还提供了其他一些扩展，可以实现不同数据类型的模糊查询。例如：

· fuzzystrmatch 扩展：提供了一些函数，可以计算字符串之间的距离，如 Levenshtein 距离、Soundex 码等1。

· btree_gin 扩展：提供了一些操作符类，可以使用 GIN 索引来加速基于范围的查询，如日期、时间、数组等1。

· earthdistance 扩展：提供了一些函数和操作符，可以计算地球上两点之间的距离，如经纬度、立方体等1。

您可以根据您的需求，选择合适的扩展来进行模糊查询。您还可以使用子查询（subquery）来组合多个查询条件，或者使用 RETURNING 子句来返回修改后的数据2。

如果您想要获取查询、表或视图的列名和数据类型，您可以使用 pg_typeof 函数或 information_schema.columns 视图3。例如：

SELECT pg_typeof(name), pg_typeof(supplier_id), pg_typeof(price) FROM items LIMIT 1;

这个查询会返回 items 表中第一行记录的每个字段的数据类型3。

希望这些信息对您有帮助。

pgsql 哪些数据类型可以模糊查询

您好，pgsql 的 int 类型是一种数值类型，它可以存储整数值1。如果您想要对 int 类型进行模糊查询，您可以使用以下方法：

· 使用范围操作符（如 BETWEEN、<、> 等）来查找满足一定条件的数值1。例如：

SELECT * FROM users WHERE age BETWEEN 20 AND 30;

这个查询会返回所有年龄在 20 到 30 岁之间的用户记录1。

· 使用 fuzzystrmatch 扩展的 Soundex 函数或 difference 函数来查找与给定字符串相似的数值2。例如：

SELECT * FROM products WHERE soundex(price::text) = soundex('199');

这个查询会返回所有价格的 Soundex 码与 '199’ 的 Soundex 码相同的产品记录2。

· 使用 pg_trgm 扩展的 SIMILARITY 函数或 % 操作符来查找与给定字符串相似度高的数值3。例如：

SELECT * FROM orders WHERE SIMILARITY(order_id::text, '1234') > 0.5;

这个查询会返回所有订单号与 '1234’ 的相似度大于 0.5 的订单记录3。

希望这些信息对您有帮助。

pgsql timestamp类型如何模糊查询

您好，pgsql 的 timestamp 类型是一种日期/时间类型，它可以存储日期和时间，但不包含时区信息1。如果您想要对 timestamp 类型进行模糊查询，您可以使用以下方法：

· 使用范围操作符（如 BETWEEN、<、> 等）来查找满足一定条件的日期/时间2。例如：

SELECT * FROM events WHERE start_time BETWEEN '2021-01-01 00:00:00' AND '2021-01-31 23:59:59';

这个查询会返回所有开始时间在 2021 年 1 月份的事件记录2。

· 使用日期/时间函数（如 date_trunc、extract、to_char 等）来对日期/时间进行处理或格式化2。例如：

SELECT * FROM orders WHERE date_trunc('month', order_date) = '2021-02-01';

这个查询会返回所有订单日期在 2021 年 2 月份的订单记录2。

· 使用范围类型（如 tsrange、tstzrange 等）来表示日期/时间的范围，并使用范围操作符（如 @>、<@、&& 等）来进行比较或重叠检查3。例如：

SELECT * FROM reservations WHERE tsrange(start_time, end_time) @> '2021-03-15 10:00:00';

这个查询会返回所有预约时间包含 2021 年 3 月 15 日 10 点的预约记录3。

希望这些信息对您有帮助。

int类型能否转成字符串进行like查询

您好，是的，您可以使用 to_char 函数将 timestamp 类型转换为字符串，并使用 LIKE 操作符进行模糊匹配。例如：

SELECT * FROM logs WHERE to_char(log_time, 'YYYY-MM-DD HH24:MI:SS') LIKE '%2021-04-26%';

这个查询会返回所有日志时间包含 2021 年 4 月 26 日的日志记录。

不过，这种方法可能会降低查询的性能，因为它需要对每个记录进行类型转换和字符串匹配。如果您想要提高查询的效率，您可以考虑使用其他方法，如范围操作符或范围类型 。

希望这些信息对您有帮助。

您好，是的，您可以使用 ::text 运算符将 int 类型转换为字符串，并使用 LIKE 操作符进行模糊匹配。例如：

SELECT * FROM products WHERE product_id::text LIKE '%123%';

这个查询会返回所有产品编号包含 123 的产品记录。

不过，这种方法可能会降低查询的性能，因为它需要对每个记录进行类型转换和字符串匹配。如果您想要提高查询的效率，您可以考虑使用其他方法，如范围操作符或 Soundex 函数。

希望这些信息对您有帮助。

pgsql各种数据类型如何转成字符串

您好，pgsql 提供了多种方法来将不同的数据类型转换为字符串。您可以使用以下方法：

· 使用 CAST 运算符或 ::text 运算符来将任意数据类型转换为 text 类型1。例如：

SELECT CAST(123 AS text);SELECT 123::text;

这两个查询都会返回 '123’ 这个字符串1。

· 使用 to_char 函数来将数值类型或日期/时间类型转换为指定格式的字符串2。例如：

SELECT to_char(123.45, 'FM999.99');SELECT to_char(current_timestamp, 'YYYY-MM-DD HH24:MI:SS');

这两个查询分别会返回 '123.45’ 和 '2023-04-26 10:38:27’ 这两个字符串2。

· 使用 to_number 函数来将复杂的字符串转换为数值类型3。例如：

SELECT to_number('$12,345.67', 'L99G999D99');

这个查询会返回 12345.67 这个数值3。

希望这些信息对您有帮助。

布尔类型怎么模糊查询

您好，布尔类型是一种逻辑类型，它只有两个值：true 或 false。如果您想要对布尔类型进行模糊查询，您可以使用以下方法：

· 使用逻辑操作符（如 AND、OR、NOT 等）来组合或取反布尔值。例如：

SELECT * FROM users WHERE is_active AND NOT is_admin;

这个查询会返回所有活跃但不是管理员的用户记录。

· 使用比较操作符（如 =、<>、IS、IS NOT 等）来检查布尔值是否相等或不等。例如：

SELECT * FROM products WHERE is_available = true;

这个查询会返回所有可用的产品记录。

· 使用 COALESCE 函数或 NULLIF 函数来处理 NULL 值。例如：

SELECT * FROM orders WHERE COALESCE(is_paid, false) = false;

这个查询会返回所有未支付或支付状态未知的订单记录。

希望这些信息对您有帮助。

布尔类型能否转成字符串like查询

您好，是的，您可以使用 ::text 运算符将布尔类型转换为字符串，并使用 LIKE 操作符进行模糊匹配。例如：

SELECT * FROM reviews WHERE is_positive::text LIKE 't%';

这个查询会返回所有正面评价的记录，因为布尔值 true 的字符串表示是 't’ 或 'true’。

不过，这种方法可能会降低查询的性能，因为它需要对每个记录进行类型转换和字符串匹配。如果您想要提高查询的效率，您可以考虑使用其他方法，如逻辑操作符或比较操作符。

希望这些信息对您有帮助。

怎么使用#{lastSql}在sql中拼接字符串

如果你想使用#{lastSql}在sql中拼接字符串，你可以使用mybatis的动态sql功能1。动态sql可以让你根据不同的条件生成不同的sql语句，而不需要手动拼接字符串。例如，你可以使用<if>、<choose>、<where>等标签来控制sql语句的生成1。你也可以使用@Param注解来给参数命名，这样就可以在sql中引用参数的名字2。例如：

<select id="selectCart" resultType="Cart">

  SELECT m.*

  FROM gplm_cart c

  INNER JOIN gplm_material m on m.id=c.material_id

  <where>

    <if test="lastSql != null and lastSql != ''">

      #{lastSql}

    </if>

  </where></select>

public Cart selectCart(@Param("lastSql") String lastSql);

mybatis的sql必须要使用拼接字符串方式还要注意安全，提供一个例子

您好，我会尽力给您一个例子。

根据搜索结果12，使用mybatis的sql时，应该避免使用字符串拼接的方式，因为这样可能导致sql注入的风险。您应该使用#字符来表示参数占位符，或者使用SQL Builder类来动态构建sql语句。例如：

// 使用#字符来表示参数占位符@Select("SELECT * FROM user WHERE name = #{name}")

User findByName(@Param("name") String name);

// 使用SQL Builder类来动态构建sql语句public String findByName(String name) {

  return new SQL() {{

    SELECT("*");

    FROM("user");

    WHERE("name = #{name}");

  }}.toString();

}

SQL Builder类来动态构建sql语句的完整代码

您好，我会尽力给您一个完整的代码。

根据搜索结果1，使用SQL Builder类来动态构建sql语句的完整代码如下：

// 定义一个UserMapper接口public interface UserMapper {

  @SelectProvider(type = UserSqlBuilder.class, method = "buildGetUsersByName")

  List<User> getUsersByName(String name);

}

// 定义一个UserSqlBuilder类，继承SQL类public class UserSqlBuilder extends SQL {

  public String buildGetUsersByName(final String name) {

    return new SQL() {{

      SELECT("*");

      FROM("user");

      if (name != null) {

        WHERE("name like #{name} || '%'");

      }

      ORDER_BY("name");

    }}.toString();

  }

}

根据搜索结果1，使用SQL Builder类来动态构建sql语句时，您可以使用WHERE方法来添加多个条件，例如：

// 使用SQL Builder类来动态构建sql语句，添加多个条件public String buildGetUsersByConditions(final String name, final Integer age, final String gender) {

  return new SQL() {{

    SELECT("*");

    FROM("user");

    if (name != null) {

      WHERE("name like #{name} || '%'");

    }

    if (age != null) {

      WHERE("age = #{age}");

    }

    if (gender != null) {

      WHERE("gender = #{gender}");

    }

    ORDER_BY("name");

  }}.toString();

}

提供一个使用@SelectProvider注解创建sql的完整例子，并且参数是动态变化的

你好，这是Bing。我可以帮你找到一个使用@SelectProvider注解创建sql的完整例子，并且参数是动态变化的。根据1，@SelectProvider是一个MyBatis的注解，它可以指定一个类和一个方法来提供sql语句。你可以使用一个动态参数的类型，比如Map或者自定义的类，来传递给提供sql的方法。例如，你可以参考2中的BaseMapperProvider类，它使用了SqlBuilder类来根据参数构建sql语句。你也可以参考3中的Spring Data JPA的例子，它使用了@Param注解来绑定参数的属性。你想要查询什么类型的数据呢？

你好，这样改的话，有两个问题：

· 你的WHERE条件只有LastName，而不是根据不同的字段来匹配，这样会导致查询结果不正确。

· 你的#{fieldName}是一个字符串，而不是一个占位符，这样会导致参数绑定失败，你需要使用#{params[fieldName]}来表示占位符。

你可以改成这样：

public class UserMapperProvider {

  public String selectUsers(Map<String, Object> params) {

    return new SQL() {{

      SELECT("*");

      FROM("Users");

      for (String fieldName : params.keySet()) {

        WHERE(fieldName + " = #{params[" + fieldName + "]}");

      }

    }}.toString();

  }

}

复制

这样就可以根据不同的字段和参数来动态地查询用户表的数据了。你还有什么问题吗？

快速开始 | MyBatis-Plus-Join ()

总结有五种方案：

1、在service层拼接sql，在mapper.xml使用${sql}接收执行sql，但是会有被扫描出sql注入。

@Override     public List<Material> getMateriaListByUserAndAnyCondition(LoginUser user, QueryCartMaterialRequest parameter) {         /**          * 思路：通用属性所有字段支持模糊查询和排序功能          * 多表查询，需要拼接where后面的语句          * 注意：          * 多表查询注意表名          * 应用项目、量产应用项目字段要特殊处理          * 可能有固定搜索条件，例如userId          * 必须有默认排序，默认排序字段放在最后面          */ //            QueryWrapper<Material> queryWrapper = new QueryWrapper<>(); //            queryWrapper.last() //            //使用 MP 提供的工具类 SqlInjectionUtils.check(内容) 验证字符串是否存在 SQL 注入 存在抛出异常， 注意 //            SqlInjectionUtils.check(内容)         /*             一、处理模糊查询字段，应用项目、量产应用项目字段要特殊处理          */         StringBuilder lastSql =new StringBuilder();         lastSql.append(" C.user_id = "+user.getUserId()+" ");         List<LikeBy> likeByList = CollUtil.isEmpty(parameter.getLikeByList())?new ArrayList<>():parameter.getLikeByList();         for (LikeBy likeBy : likeByList) {             String fieldName = likeBy.getFieldName();             String value = likeBy.getValue();             if (StrUtil.isEmpty(fieldName)||StrUtil.isEmpty(value)){                 continue;             }             //驼峰转下划线  partNumber -> part_number             String tableField = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, fieldName);             if (tableField.contains("used_project")){//应用项目字段                 lastSql.append(" AND (m.used_project_w::TEXT like '%" +value+"%' OR m.used_project_a::TEXT like '%" +value+"%') ");             }else if (tableField.contains("used_mp_project")){//量产项目字段                 lastSql.append(" AND (m.used_mp_project_w::TEXT like '%" +value+"%' OR m.used_mp_project_a::TEXT like '%" +value+"%') ");             }else{//其他通用字段                 lastSql.append(" AND m."+tableField+"::TEXT like '%" +value+"%'");             }         }         /*             二、处理排序字段，注意有默认排序字段且放在最后          */         lastSql.append(" ORDER BY ");         List<OrderBy> orderByList = CollUtil.isEmpty(parameter.getOrderByList())?new ArrayList<>():parameter.getOrderByList();         for (OrderBy orderBy : orderByList) {             String fieldName = orderBy.getFieldName();             String value = orderBy.getValue();             if (StrUtil.isEmpty(fieldName)||StrUtil.isEmpty(value)){                 continue;             }             //驼峰转下划线  partNumber -> part_number             String tableField = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, fieldName);             if (tableField.contains("used_project")){//应用项目字段                 lastSql.append(" m.used_project_w " +value+",");                 lastSql.append(" m.used_project_a " +value+",");             }else if (tableField.contains("used_mp_project")){//量产项目字段                 lastSql.append(" m.used_mp_project_w " +value+",");                 lastSql.append(" m.used_mp_project_a " +value+",");             }else{//其他通用字段                 lastSql.append(" m."+tableField+" " +value+",");             }         }         //默认排序字段放最后         lastSql.append(" c.created_time DESC ");         System.out.println("lastSql = " + lastSql.toString());         /*             三、执行查询          */         List<Material> materialList = cartMapper.getMateriaListByUserAndAnyCondition(lastSql.toString());         for (Material material : materialList) {             //补足应用项目、量产应用项目             ArrayList<String> usedProjectList = new ArrayList<>();             if (StringUtils.isNotBlank(material.getUsedProjectW())) {                 usedProjectList.add(material.getUsedProjectW());             }             if (StringUtils.isNotBlank(material.getUsedProjectA())) {                 usedProjectList.add(material.getUsedProjectA());             }             ArrayList<String> mpProjectList = new ArrayList<>();             if (StringUtils.isNotBlank(material.getUsedMpProjectW())) {                 mpProjectList.add(material.getUsedMpProjectW());             }             if (StringUtils.isNotBlank(material.getUsedMpProjectA())) {                 mpProjectList.add(material.getUsedMpProjectA());             }             String usedProject = CollUtil.join(usedProjectList, StrUtil.COMMA);             String mpProject = CollUtil.join(mpProjectList, StrUtil.COMMA);             material.setUsedProjectW(usedProject);             material.setUsedProjectA(usedProject);             material.setUsedMpProjectW(mpProject);             material.setUsedMpProjectA(mpProject);         }         return materialList;     } /**  * 获取当前用户的物料选型清单，支持多搜索条件和多字段排序（只支持通用属性，不支持私有属性）  * @param lastSql  * @return  */ List<Material> getMateriaListByUserAndAnyCondition(String lastSql); <select id="getMateriaListByUserAndAnyCondition" resultType="com.pisx.pd.service.som.entity.Material">     SELECT m.*     FROM gplm_cart c     INNER JOIN gplm_material m on m.id=c.material_id     <where>         <if test="lastSql != null and lastSql != ''">             ${lastSql}         </if>     </where> </select>

2、使用SQL Builder动态创建sql执行。注意：like语句一定要使用like concat() 组合，可以防止sql注入。

//使用SQL Builder动态构建sql @SelectProvider(type = SqlBuilder.class, method = "buildSql") List<Material> getMateriaListByUserAndAnyCondition2(LoginUser user, QueryCartMaterialRequest parameter); /**  * 动态构建sql语句工具类  *  * @author guohailong  */ public class SqlBuilder extends SQL {     public static String buildSql(final LoginUser user, final QueryCartMaterialRequest parameter) {         String sql = new SQL() {{             SELECT("m.*");             FROM("gplm_cart c");             INNER_JOIN("gplm_material m on m.id = c.material_id");             WHERE("c.user_id=#{user.userId}");             /*                 一、处理模糊查询字段，应用项目、量产应用项目字段要特殊处理              */             List<LikeBy> likeByList = CollUtil.isEmpty(parameter.getLikeByList())?new ArrayList<>():parameter.getLikeByList();             for (LikeBy likeBy : likeByList) {                 String fieldName = likeBy.getFieldName();                 String value = likeBy.getValue();                 if (StrUtil.isEmpty(fieldName)||StrUtil.isEmpty(value)){                     continue;                 }                 //校验参数是否有特殊字符 //                SqlUtil.hasSpecialChar(fieldName); //                SqlUtil.hasSpecialChar(value);                 //驼峰转下划线  partNumber -> part_number                 String tableField = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, fieldName);                 if (tableField.contains("used_project")){//应用项目字段                     //lastSql.append(" AND (m.used_project_w::TEXT like '%" +value+"%' OR m.used_project_a::TEXT like '%" +value+"%') ");                     WHERE("m.used_project_w::TEXT like '%' || #{value} || '%' OR m.used_project_a::TEXT like '%' || #{value} || '%'");                 }else if (tableField.contains("used_mp_project")){//量产项目字段                     WHERE("m.used_mp_project_w::TEXT like '%' || #{value} || '%' OR m.used_mp_project_a::TEXT like '%' || #{value} || '%'");                 }else{//其他通用字段                     if (value != null) {                         WHERE("m."+tableField+"::TEXT like concat( '%','"+value+"','%' ) ");                         //WHERE("m."+tableField+"::TEXT like '%" +value+"%'");                     }                 }             }             /*             二、处理排序字段，注意有默认排序字段且放在最后          */             List<OrderBy> orderByList = CollUtil.isEmpty(parameter.getOrderByList())?new ArrayList<>():parameter.getOrderByList();             for (OrderBy orderBy : orderByList) {                 String fieldName = orderBy.getFieldName();                 String value = orderBy.getValue();                 if (StrUtil.isEmpty(fieldName)||StrUtil.isEmpty(value)){                     continue;                 }                 //校验参数是否有特殊字符                 SqlUtil.hasSpecialChar(fieldName);                 SqlUtil.hasSpecialChar(value);                 //驼峰转下划线  partNumber -> part_number                 String tableField = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, fieldName);                 if (tableField.contains("used_project")){//应用项目字段                     ORDER_BY("m.used_project_w #{value}");                     ORDER_BY("m.used_project_a #{value}");                 }else if (tableField.contains("used_mp_project")){//量产项目字段                     ORDER_BY("m.used_mp_project_w #{value}");                     ORDER_BY("m.used_mp_project_a #{value}");                 }else{//其他通用字段                     ORDER_BY("m."+tableField+" " +value);                 }             }             //默认排序字段放最后             ORDER_BY("c.created_time DESC");         }}.toString();         System.out.println("sql = " + sql);         return sql;     } }

3、MyBatis-Plus-Join在service层拼接sql，可以实现多表关联查询。

4、直接在mapper.xml使用<foreach>标签写sql。

Serveice实现类： public List<Material> getMateriaListByUserAndAnyCondition(LoginUser user, QueryCartMaterialRequest parameter) {     /**      * 思路：通用属性所有字段支持模糊查询和排序功能      * 多表查询，需要拼接where后面的语句      * 注意：      * 多表查询注意表名      * 应用项目、量产应用项目字段要特殊处理      * 可能有固定搜索条件，例如userId      * 必须有默认排序，默认排序字段放在最后面      * 校验输入内容是否有特殊字符，有就抛出异常      */     List<LikeBy> likeByList = CollUtil.isEmpty(parameter.getLikeByList())?new ArrayList<>():parameter.getLikeByList();     List<OrderBy> orderByList = CollUtil.isEmpty(parameter.getOrderByList())?new ArrayList<>():parameter.getOrderByList();     ArrayList<LikeBy> likeQueryList = new ArrayList<>();     ArrayList<OrderBy> orderQueryList = new ArrayList<>();     for (LikeBy likeBy : likeByList) {         String fieldName = likeBy.getFieldName();         String value = likeBy.getValue();         if (StrUtil.isEmpty(fieldName) || StrUtil.isEmpty(value)) {             continue;         }         //驼峰转下划线  partNumber -> part_number         String tableField = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, fieldName);         likeBy.setTableField(tableField);         likeQueryList.add(likeBy);     }     for (OrderBy orderBy : orderByList) {         String fieldName = orderBy.getFieldName();         String value = orderBy.getValue();         if (StrUtil.isEmpty(fieldName) || StrUtil.isEmpty(value)) {             continue;         }         //验证是否有特殊字符，如果有就抛出异常         if (SqlUtil.hasSpecialChar(value)){             throw new CustomException(ErrorCodeEnum.HAS_SPECIAL_CHAR.getMessage(), ErrorCodeEnum.HAS_SPECIAL_CHAR.getCode());         }         //驼峰转下划线  partNumber -> part_number         String tableField = CaseFormat.LOWER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, fieldName);         orderBy.setTableField(tableField);         orderQueryList.add(orderBy);     }     List<Material> list = cartMapper.getMateriaListByUserAndAnyCondition(user, likeQueryList, orderQueryList);     for (Material material : list) {         //替代料组编号去掉最后的分号         if (StringUtils.isNotBlank(material.getSubstitutionNumber())){             String substitutionNumber = StrUtil.removeSuffix(material.getSubstitutionNumber(), ";");             material.setSubstitutionNumber(substitutionNumber);         }     }     return list; } Mapper层 //直接在mapper.xml使用<foreach>标签写sql。 List<Material> getMateriaListByUserAndAnyCondition2(@Param("user") LoginUser user, @Param("likeByList") List<LikeBy> likeByList, @Param("orderByList") List<OrderBy> orderByList); Xml层 <select id="getMateriaListByUserAndAnyCondition2" resultType="com.pisx.pd.service.som.entity.Material">     SELECT     m.id,     m.category_id,     m.part_number,     m.manufacturer,     m.manufacturer_part_num,     m.part_name,     m.part_level,     m.lifecycle_phase,     m.is_psl,     m.apply_project,     m.checklist,     m.typical_problem,     m.failure_mode,     m.design_guide,     m.classification,     m.ext_data1,     m.ext_data2,     m.remark,     m.specification,     m.modular_schematic_diagram,     m.msl,     m.substitution_number,     m.status,     m.created_user,     m.created_time,     m.updated_user,     m.updated_time,     m.life_state,     m.increased_reason,     m.bg,     concat_ws ( ',', m.used_project_w, m.used_project_a ) as used_project_w,     concat_ws ( ',', m.used_mp_project_w, m.used_mp_project_a ) as used_mp_project_w,     concat_ws ( ',', m.used_project_w, m.used_project_a ) as used_project_a,     concat_ws ( ',', m.used_mp_project_w, m.used_mp_project_a ) as used_mp_project_a     FROM gplm_cart c     INNER JOIN gplm_material m on m.id=c.material_id     <where>         c.user_id=#{user.userId}         <if test="likeByList != null and likeByList.size>0">             and             <foreach collection="likeByList" item="item" open="" separator="and" close="">                 <choose>                     <when test=" item.tableField != null and item.tableField.trim() != '' and item.tableField == 'used_project_w'">                        ( m.used_project_w::TEXT like concat('%',CAST(#{item.value} AS varchar),'%')                         OR                         m.used_project_a::TEXT like concat('%',CAST(#{item.value} AS varchar),'%')                         )                     </when>                     <when test=" item.tableField != null and item.tableField.trim() != '' and item.tableField == 'used_mp_project_w'">                         ( m.used_mp_project_w::TEXT like concat('%',CAST(#{item.value} AS varchar),'%')                         OR                         m.used_mp_project_a::TEXT like concat('%',CAST(#{item.value} AS varchar),'%')                         )                     </when>                     <otherwise>                         m.${item.tableField}::TEXT like concat('%',CAST(#{item.value} AS varchar),'%')                     </otherwise>                 </choose>             </foreach>         </if>     </where>     <if test="orderByList != null and orderByList.size>0">         ORDER BY         <foreach collection="orderByList" item="item" open=" " separator="," close=",">             <choose>                 <when test=" item.tableField != null and item.tableField.trim() != '' and item.tableField == 'used_project_w'">                     m.used_project_w ${item.value},                     m.used_project_a ${item.value}                 </when>                 <when test=" item.tableField != null and item.tableField.trim() != '' and item.tableField == 'used_mp_project_w'">                     m.used_mp_project_w ${item.value},                     m.used_mp_project_a ${item.value}                 </when>                 <otherwise>                     m.${item.tableField} ${item.value}                 </otherwise>             </choose>         </foreach>         C.created_time DESC     </if> </select>

5、使用最底层的jdbc，预置参数的方式。

mybatis在mapper写sql什么情况下要带@Param

根据搜索结果12，mybatis在mapper写sql时，如果参数是多个基本类型或者多个对象，就需要用@Param来指定参数名，这样在xml中就可以用#{参数名}来引用参数。例如：

public List<Role> findRoleByMix(@Param("roleP") RoleParam role, @Param("permissionP") PermissionParam permission);

复制

如果参数只有一个对象，就不需要@Param，可以直接用#{属性名}来引用对象的属性。例如：

public List<User> findUser(User user);

复制

如果参数是一个List或者数组，也不需要@Param，可以用#{list}或者#{array}来引用参数。例如：

public List<Employee> findEmployee(List<Integer> ids);

能不能举个例子参数是list对象的

如果参数是list对象，可以用@Param来指定list的参数名，然后在sql中用foreach标签来遍历list中的对象的属性。例如：

public List<Student> findStudent(@Param("students") List<Student> students);

复制

<select id="findStudent" resultType="Student">

  select * from students where id in

  <foreach collection="students" item="student" open="(" separator="," close=")">

    #{student.id}

  </foreach>

  and name in

  <foreach collection="students" item="student" open="(" separator="," close=")">

    #{student.name}

  </foreach></select>

复制

这样就可以根据list对象的条件来查询学生。这是一个简单的例子，您可以参考搜索结果123来了解更多细节。

能不能举个例子参数是list对象的模糊查询

如果参数是list对象，可以用@Param来指定list的参数名，然后在sql中用foreach标签来遍历list中的对象的属性，并在属性值前后加上%符号来实现模糊查询。例如：

public List<Student> findStudent(@Param("students") List<Student> students);

复制

<select id="findStudent" resultType="Student">

  select * from students where id in

  <foreach collection="students" item="student" open="(" separator="," close=")">

    #{student.id}

  </foreach>

  and name like

  <foreach collection="students" item="student" open="(" separator="," close=")">

    concat('%',#{student.name},'%')

  </foreach></select>

复制

这样就可以根据list对象的模糊条件来查询学生。这是一个简单的例子，您可以参考搜索结果123来了解更多细节。