mysql exist 多条数据

如果您想要查询一个表中是否存在多条数据，可以使用以下 SQL 语句：

SELECT COUNT(*) FROM table_name WHERE conditions;

其中，`table_name` 是您要查询的表名，`conditions` 是查询条件。如果查询结果返回的 `COUNT(*)` 值大于 1，就说明表中存在多条符合条件的数据。

另外，如果您只是想判断表中是否存在符合条件的数据，可以使用 `EXISTS` 关键字，例如：

SELECT EXISTS(SELECT 1 FROM table_name WHERE conditions);

如果查询结果返回的值为 1，则说明表中存在符合条件的数据；如果返回值为 0，则说明不存在。

相关问题

MYSQL 版本5.7.26-log，mysql中有一张表,通过id和parentid实现父子关系的关联,而且父子关系是多层.在java中如何使用mybatisplus实现.抽出某一条数据的所有父数据和子数据...

可以使用MyBatis-Plus的递归查询来实现该功能。

首先，在定义对应实体类时，需要添加一个自关联属性，例如：

public class TreeNode {
    private Long id;
    private Long parentId;
    private String name;
    // 自关联属性
    @TableField(exist = false)
    private List<TreeNode> children;
    // getter 和 setter 略
}

然后，在Mapper接口中，使用递归查询的方式来实现该功能：

public interface TreeNodeMapper extends BaseMapper<TreeNode> {
    /**
     * 递归查询某个节点的所有子节点
     *
     * @param parentId 父节点id
     * @return 子节点列表
     */
    @Select("with recursive cte(id, parent_id, name, path) as (\n" +
            "  select id, parent_id, name, cast(id as char(200)) as path from tree_node where parent_id = #{parentId}\n" +
            "  union all\n" +
            "  select c.id, c.parent_id, c.name, concat(p.path, ',', c.id) as path from tree_node c\n" +
            "    inner join cte p on c.parent_id = p.id\n" +
            ")\n" +
            "select * from cte")
    List<TreeNode> selectChildren(Long parentId);

    /**
     * 递归查询某个节点的所有父节点
     *
     * @param id 节点id
     * @return 父节点列表
     */
    @Select("with recursive cte(id, parent_id, name, path) as (\n" +
            "  select id, parent_id, name, cast(id as char(200)) as path from tree_node where id = #{id}\n" +
            "  union all\n" +
            "  select p.id, p.parent_id, p.name, concat(p.id, ',', c.path) as path from tree_node p\n" +
            "    inner join cte c on p.id = c.parent_id\n" +
            ")\n" +
            "select * from cte")
    List<TreeNode> selectParents(Long id);
}

其中，`selectChildren`方法用于查询某个节点的所有子节点，`selectParents`方法用于查询某个节点的所有父节点。

使用方式如下：

@Autowired
private TreeNodeMapper treeNodeMapper;

public void test() {
    // 查询id为1的节点的所有子节点
    List<TreeNode> children = treeNodeMapper.selectChildren(1L);
    // 查询id为5的节点的所有父节点
    List<TreeNode> parents = treeNodeMapper.selectParents(5L);
}

这样就可以使用MyBatis-Plus来实现该功能了。

mysql中有一张表,通过id和parentid实现父子关系的关联,而且父子关系是多层.在java中如何使用mybatisplus实现.抽出某一条数据的所有父数据和子数据...

可以使用Mybatis-Plus提供的Tree模型来实现父子关系的查询。

首先，需要在实体类中定义一个Tree模型的父子关系属性，例如：

@Data
public class TreeNode {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    private Long parentId;

    @TableField(exist = false)
    private List<TreeNode> children;
}

其中，`children`属性表示当前节点的子节点列表。

然后，在Mapper接口中继承`TreeMapper`接口，例如：

public interface TreeNodeMapper extends BaseMapper<TreeNode>, TreeMapper<TreeNode> {
}

接着，在Service层中，可以使用`selectList`方法查询所有节点，并使用`buildTree`方法构建树形结构，例如：

@Service
public class TreeNodeService extends ServiceImpl<TreeNodeMapper, TreeNode> {
    public List<TreeNode> getTree() {
        List<TreeNode> list = baseMapper.selectList(null);
        return buildTree(list, 0L);
    }

    private List<TreeNode> buildTree(List<TreeNode> list, Long parentId) {
        List<TreeNode> tree = new ArrayList<>();
        for (TreeNode node : list) {
            if (node.getParentId().equals(parentId)) {
                node.setChildren(buildTree(list, node.getId()));
                tree.add(node);
            }
        }
        return tree;
    }
}

最后，在Controller中调用Service的`getTree`方法获取整棵树，例如：

@RestController
public class TreeNodeController {
    @Autowired
    private TreeNodeService treeNodeService;

    @GetMapping("/tree")
    public List<TreeNode> getTree() {
        return treeNodeService.getTree();
    }
}

如果需要抽出某一条数据的所有父数据和子数据，可以先查询出该节点的父节点列表，然后再查询出该节点的子节点列表，例如：

@Service
public class TreeNodeService extends ServiceImpl<TreeNodeMapper, TreeNode> {
    public List<TreeNode> getAncestors(Long id) {
        List<TreeNode> ancestors = new ArrayList<>();
        TreeNode node = baseMapper.selectById(id);
        while (node != null) {
            ancestors.add(node);
            node = baseMapper.selectById(node.getParentId());
        }
        return ancestors;
    }

    public List<TreeNode> getDescendants(Long id) {
        List<TreeNode> descendants = new ArrayList<>();
        Queue<Long> queue = new LinkedList<>();
        queue.offer(id);
        while (!queue.isEmpty()) {
            Long parentId = queue.poll();
            List<TreeNode> children = baseMapper.selectList(new QueryWrapper<TreeNode>()
                    .eq("parent_id", parentId));
            descendants.addAll(children);
            for (TreeNode child : children) {
                queue.offer(child.getId());
            }
        }
        return descendants;
    }
}

其中，`getAncestors`方法查询出当前节点的所有祖先节点，`getDescendants`方法查询出当前节点的所有子孙节点。这两个方法可以结合起来，获取某一条数据的所有父数据和子数据，例如：

@RestController
public class TreeNodeController {
    @Autowired
    private TreeNodeService treeNodeService;

    @GetMapping("/data/{id}")
    public Map<String, Object> getData(@PathVariable("id") Long id) {
        Map<String, Object> data = new HashMap<>();
        data.put("node", treeNodeService.getById(id));
        data.put("ancestors", treeNodeService.getAncestors(id));
        data.put("descendants", treeNodeService.getDescendants(id));
        return data;
    }
}