皇家德州-医院妇科治疗烤肚子的叫什么名字

首页

AD联系:507867812

皇家德州

时间:2019-11-21 11:28:31 作者:水果老虎机 浏览量:63909

皇家德州MySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用,见下图

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

MySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux,见下图

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux,如下图

MySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用

MySQL递归查询与GROUP_CONCAT组合结果集的使用

如下图

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux,如下图

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用,见图

皇家德州MySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

MySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

MySQL递归查询与GROUP_CONCAT组合结果集的使用

MySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

皇家德州

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

MySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用。

MySQL递归查询与GROUP_CONCAT组合结果集的使用

1.

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

MySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用

2.MySQL递归查询与GROUP_CONCAT组合结果集的使用。

MySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

3.MySQL递归查询与GROUP_CONCAT组合结果集的使用。

MySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用

4.MySQL递归查询与GROUP_CONCAT组合结果集的使用。

MySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linuxMySQL递归查询与GROUP_CONCAT组合结果集的使用MySQL递归查询与GROUP_CONCAT组合结果集的使用

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux。皇家德州

展开全文
相关文章
通比牛牛

MySQL递归查询与GROUP_CONCAT组合结果集的使用

炸金花

MySQL递归查询与GROUP_CONCAT组合结果集的使用....

威尼斯人电子游戏

MySQL递归查询与GROUP_CONCAT组合结果集的使用....

通宝pt老虎机

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux....

伟德备用网址

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux....

相关资讯
威尼斯人高尔夫赌场

1-前言:

在MySQL使用递归查询是很不方便的,不像SQL Server可以直接使用声明变量,使用虚拟表等等。如:DECLARE,BEGIN ... END ,WHILE ,IF 等等。

在MySQL可以通过创建函数,来使用上面的流程控制语句,Mysql对函数的语法检查也是很苛刻的,可以说很烦人,不熟悉的人估计会哭。

2-递归查询关键部分:

  a-我的表结构:

  

  b-我的递归脚本:

  用于查询:当前类目ID及所有的父级元素的ID使用逗号分割开的一个字符串:

  下面脚本里使用了组合结果集的一个函数:GROUP_CONCAT,使用该函数可以在查不到结果的时候继续给pid赋值,从而跳出循环,详细可参考文章下面的注意点。

  SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid赋值,pid结果不变,

  SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,pid结果为NULL

DROP FUNCTION IF EXISTS `fn_getLeimuPath`;CREATE DEFINER = `sa`@`%` FUNCTION `fn_getLeimuPath`(`subId` int) RETURNS varchar(1000)BEGINDECLARE pathID VARCHAR(4000) DEFAULT subId;DECLARE pid INT default subid;WHILE pid>0 DO SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE ID = pid; IF pid>0 THEN SET pathID = concat(pid, ',', pathID); END IF;END WHILE;RETURN pathID;END;

  查询结果展示:

  

3-一些需要注意的点,函数的一些特殊语法检查:

a-脚本结束标记检查: 分号检查:

  如:每个独立的脚本语句; 流程控制语句结尾:END IF; END; END WHILE;

b-流程控制语句组合:

  如:

   IF 条件 THEN

    代码

  ELSEIF

    代码

END IF;

  WHILE 条件 DO

    代码

  END WHILE;

c-特殊函数的使用:

  函数:GROUP_CONCAT:将结果集链接在一起,使用逗号分隔,group_concat([DISTINCT] 要连接的字段 [Order BY ASC/DESC 排序字段] [Separator ‘分隔符’])

  备注: 这个函数可以在找不到数据的情况下,继续执行从而给INTO的变量赋值。 比较神奇:

SELECT ParentID INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下, INTO 无法给pid的结果不变,SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2; -- 找不到数据的情况下,通过函数GROUP_CONCAT组合之后,可以继续使用INTO 给pid赋值,NULL  我们这里是想在查不到的结果的时候,通过WHILE的判断结束循环,如果不通过GROUP_CONCAT函数将结果传给pid,那么将会进入无线循环当中,是很坑的!! 下面脚本的代码结果是:2DECLARE pid INT;SELECT ParentID INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=1;END IF;SELECT GROUP_CONCAT(ParentID) INTO pid FROM product_leimu WHERE 1=2;IF pid IS NULL THEN SET pid=2;END IF;linux....

热门资讯