MariaDB 特性介绍-动态虚拟列_MySQL_领测软件测试网
MariaDB 特性介绍-动态虚拟列
发表于：来源：OurMySLQ作者：不详点击数：
MariaDB 特性介绍-动态虚拟列 MariaDB为NoSQL的扩展提供的另外一个特性 就是：动态列。对表的每一行都可以有一个“虚拟列”，该列可以用于保存一个对象的不同属性，每个属性在各行之间可以完全不同，“虚拟列”的个数和内容完全有应用程序来控制和解释
　　MariaDB 特性介绍-动态虚拟列
　　MariaDB为No的扩展提供的另外一个特性 就是：动态列。对表的每一行都可以有一个&虚拟列&，该列可以用于保存一个对象的不同属性，每个属性在各行之间可以完全不同，&虚拟列&的个数和内容完全有应用程序来控制和解释。
　　NoSQL的另外一个好处就是，我存储的东西是一个没有结构的东西，而则要求是一个固定列名，确定长度的一个个列。为了满足这个，MariaDB引入了动态列的概念。它允许你在每一行上有一个&虚拟列&。这个虚拟列被作为一个额外的字段存在在blob中，并且有一系列函数用于创建，更新，删除，检查，查询这个列。 空说无凭，举例为证。我们先创建一个表t1，用来存储shirt,phone,computer商品的价格，其中dynstr就是用于做虚拟列的：
　　create table t1 (id int auto_increment primary key,
　　name varchar(40),
　　type enum (&shirt&, &phone&, &computer&),
　　price decimal(10,2),
　　dynstr mediumblob);
　　并插入一些数据：
　　insert into t1 (name, type, price, dynstr) values
　　(&Funny shirt&, &shirt&, 10.0, COLUMN_CREATE(1, &blue&, 10, &XL&)),
　　(&nokia&, &phone&, 649, COLUMN_CREATE(1, &black&, 2, &touchscreen&)),
　　(&htc Desire hd&, &phone&, 579, COLUMN_CREATE(1, &black&, 3, &Android&)),
　　(&BM/Lenovo Thinkpad X60s&, &computer&, 419, COLUMN_CREATE(1, &black&, 3, &&));
　　这里利用了COLUMN_CREATE()函数来创建动态列。插入的四条数据。针对各个不同的商品定义不同的属性。比如1在各个商品中表示的是颜色;3表示的是操作系统;10表示的是大小。每行数据的属性不完全相同，也不要求所有的属性值都需要包含在动态列中。那么，动态列的有哪些属性要怎么查看列：
　　select id, name, type, price, length(dynstr) as len, column_list(dynstr) as list from t1;
　　+----+-------------------------+----------+--------+------+------+
　　| id | name | type | price | len | list |
　　+----+-------------------------+----------+--------+------+------+
　　| 1 | Funny shirt | shirt | 10.00 | 17 | 1,10 |
　　| 2 | nokia | phone | 649.00 | 27 | 1,2 |
　　| 3 | htc Desire hd | phone | 579.00 | 23 | 1,3 |
　　| 4 | BM/Lenovo Thinkpad X60s | computer | 419.00 | 21 | 1,3 |
　　+----+-------------------------+----------+--------+------+------+
　　COLUMN_LIST()可以列出动态列到底有哪些属性，这样的话我们就可以根据属性过滤：
　　SELECT name FROM t1 WHERE COLUMN_GET(dynstr, 1 as char(10)) = &black&;
　　+-------------------------+
　　| name |
　　+-------------------------+
　　| nokia |
　　| htc Desire hd |
　　| BM/Lenovo Thinkpad X60s |
　　+-------------------------+
　　SELECT name, COLUMN_GET(dynstr, 1 as char(10)) FROM t1 WHERE COLUMN_EXISTS(dynstr, 1);
　　+-------------------------+--------+
　　| name | colour |
　　+-------------------------+--------+
　　| Funny shirt | blue |
　　| nokia | black |
　　| htc Desire hd | black |
　　| BM/Lenovo Thinkpad X60s | black |
　　+-------------------------+--------+
　　上面的第一条SQL查询了颜色为black的所有产品哪些属性，第二条SQL查询了存在颜色属性的所有行。对应的COLUMN_GET() 函数表示获取对应属性的属性值。COLUMN_EXISTS()函数表示动态列中是否存储了该属性值。我们也注意到，现在动态列的所有属性都是用数字来表示的。
　　前面都是对动态列创建和查询的例子，我们再看看更新的例子。比如我们需要对类型为&computer&的数据加4G内存：
　　UPDATE t1 set dynstr=COLUMN_ADD(dynstr, 15, &4G ram&) where type=&computer&;
　　SELECT name, type, price, length(dynstr) as len, column_list(dynstr) as list from t1 where type=&computer&;
　　+-------------------------+----------+--------+------+--------+
　　| name | type | price | len | list |
　　+-------------------------+----------+--------+------+--------+
　　| BM/Lenovo Thinkpad X60s | computer | 419.00 | 29 | 1,3,15 |
　　+-------------------------+----------+--------+------+--------+
　　COLUMN_ADD()函数会给每个&computer&的行加上新的属性，属性值为&4G ram&。不过，COLUMN_ADD()并不仅仅是添加，它和MySQL的replace一样，如果发现相同类型的属性，对应的属性值将被覆盖。
　　动态列现在正在快速发展期，还存在一定的限制。比如：
　　列必须通过数字来标识;
　　动态列对象最大只有字节;
　　创建索引问题;
　　具体信息参考：http://kb.askmonty.org/en/dynamic-columns/
原文转自：
评论列表（网友评论仅供网友表达个人看法，并不表明本站同意其观点或证实其描述）mysql多个字段拼接
Mysql的查询结果行字段拼接，可以用下面两个函数实现：
1. concat函数
& select concat('1','2','3')
+---------------------+
| concat('1','2','3') |
+---------------------+
+---------------------+
如果连接串中存在NULL，则返回结果为NULL：
mysql& select concat('1','2',NULL,'3')
+--------------------------+
| concat('1','2',NULL,'3') |
+--------------------------+
+--------------------------+
2. concat_ws函数
concat(separator,str1,str2,...) 代表 concat with separator ，是concat()的特殊形式。第一个参数是其它参数的分隔符。分隔符的位置放在要连接的两个字符串之间。分隔符可以是一个字符串，也可以是其它参数。
mysql& select concat_ws(':','1','2','3')
+----------------------------+
| concat_ws(':','1','2','3') |
+----------------------------+
+----------------------------+
分隔符为NULL，则返回结果为NULL：
mysql& select concat_ws(NULL,'1','2','3')
+-----------------------------+
| concat_ws(NULL,'1','2','3') |
+-----------------------------+
+-----------------------------+
如果参数中存在NULL，则会被忽略：
mysql& select concat_ws(':','1','2',NULL,NULL,NULL,'3')
+-------------------------------------------+
| concat_ws(':','1','2',NULL,NULL,NULL,'3') |
+-------------------------------------------+
+-------------------------------------------+
可以对NULL进行判断，并用其它值进行替
mysql& &select concat_ws(':','1','2',ifNULL(NULL,'0'),'3') from bank limit 1; &
+---------------------------------------------+
| concat_ws(':','1','2',ifNULL(NULL,'0'),'3') |
+---------------------------------------------+
| 1:2:0:3 & & & & & & & & & & & & & & & & & & |&
+---------------------------------------------+
(window.slotbydup=window.slotbydup || []).push({
id: '2467140',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467141',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467142',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467143',
container: s,
size: '1000,90',
display: 'inlay-fix'
(window.slotbydup=window.slotbydup || []).push({
id: '2467148',
container: s,
size: '1000,90',
display: 'inlay-fix'mysql 如何 动态行转列 - ITeye问答
属性表（key 中的值，存在另外一个名为 property 的表里：array( 'name'=&'姓名', 'mobile'=&'手机' )）：
期待查询结果
其中：name、mobile、age、province 为自定义属性的键，数量、名字不定；
在不使用MYSQL 存储过程的前提下如何（动态行转列）？
我当前使用的MYSQL语句，只能先通过PHP生成 IF段的语句：
IF(`key`='name',`value`,”) as name,
IF(`key`='mobile',`value`,”) as mobile,
IF(`key`='age',`value`,”) as age,
IF(`key`='province',`value`,”) as province
from 属性表 group by uid
seelct uid, group_concat(concat(key,'_',value)) as property from 属性表
试试这个，属性列中：key_value格式，检索之后在应用中分隔。
用case试试
已解决问题
未解决问题MySQL存储过程中使用动态行转列
作者：七度尘
字体：[ ] 类型：转载 时间：
这篇文章主要为大家介绍了MySQL存储过程中使用动态行转列的相关资料,需要的朋友可以参考下
本文介绍的实例成功的实现了动态行转列。下面我以一个简单的数据库为例子，说明一下。
数据表结构
这里我用一个比较简单的例子来说明，也是行转列的经典例子，就是学生的成绩
三张表：学生表、课程表、成绩表
就简单一点，学生学号、学生姓名两个字段
CREATE TABLE `student` (
`stuid` VARCHAR(16) NOT NULL COMMENT '学号',
`stunm` VARCHAR(20) NOT NULL COMMENT '学生姓名',
PRIMARY KEY (`stuid`)
COLLATE='utf8_general_ci'
ENGINE=InnoDB;
课程编号、课程名
CREATE TABLE `courses` (
`courseno` VARCHAR(20) NOT NULL,
`coursenm` VARCHAR(100) NOT NULL,
PRIMARY KEY (`courseno`)
COMMENT='课程表'
COLLATE='utf8_general_ci'
ENGINE=InnoDB;
学生学号、课程号、成绩
CREATE TABLE `score` (
`stuid` VARCHAR(16) NOT NULL,
`courseno` VARCHAR(20) NOT NULL,
`scores` FLOAT NULL DEFAULT NULL,
PRIMARY KEY (`stuid`, `courseno`)
COLLATE='utf8_general_ci'
ENGINE=InnoDB;
以上就是数据库表的结构了，这里没有建立外键，但是根据表的结构，可以清楚的看到成绩表中的学号和课程号是与学生表、课程表分别关联起来的。
/*学生表数据*/
Insert Into student (stuid, stunm) Values('1001', '张三');
Insert Into student (stuid, stunm) Values('1002', '李四');
Insert Into student (stuid, stunm) Values('1003', '赵二');
Insert Into student (stuid, stunm) Values('1004', '王五');
Insert Into student (stuid, stunm) Values('1005', '刘青');
Insert Into student (stuid, stunm) Values('1006', '周明');
/*课程表数据*/
Insert Into courses (courseno, coursenm) Values('C001', '大学语文');
Insert Into courses (courseno, coursenm) Values('C002', '新视野英语');
Insert Into courses (courseno, coursenm) Values('C003', '离散数学');
Insert Into courses (courseno, coursenm) Values('C004', '概率论与数理统计');
Insert Into courses (courseno, coursenm) Values('C005', '线性代数');
Insert Into courses (courseno, coursenm) Values('C006', '高等数学(一)');
Insert Into courses (courseno, coursenm) Values('C007', '高等数学(二)');
/*成绩表数据*/
Insert Into score(stuid, courseno, scores) Values('1001', 'C001', 67);
Insert Into score(stuid, courseno, scores) Values('1002', 'C001', 68);
Insert Into score(stuid, courseno, scores) Values('1003', 'C001', 69);
Insert Into score(stuid, courseno, scores) Values('1004', 'C001', 70);
Insert Into score(stuid, courseno, scores) Values('1005', 'C001', 71);
Insert Into score(stuid, courseno, scores) Values('1006', 'C001', 72);
Insert Into score(stuid, courseno, scores) Values('1001', 'C002', 87);
Insert Into score(stuid, courseno, scores) Values('1002', 'C002', 88);
Insert Into score(stuid, courseno, scores) Values('1003', 'C002', 89);
Insert Into score(stuid, courseno, scores) Values('1004', 'C002', 90);
Insert Into score(stuid, courseno, scores) Values('1005', 'C002', 91);
Insert Into score(stuid, courseno, scores) Values('1006', 'C002', 92);
Insert Into score(stuid, courseno, scores) Values('1001', 'C003', 83);
Insert Into score(stuid, courseno, scores) Values('1002', 'C003', 84);
Insert Into score(stuid, courseno, scores) Values('1003', 'C003', 85);
Insert Into score(stuid, courseno, scores) Values('1004', 'C003', 86);
Insert Into score(stuid, courseno, scores) Values('1005', 'C003', 87);
Insert Into score(stuid, courseno, scores) Values('1006', 'C003', 88);
Insert Into score(stuid, courseno, scores) Values('1001', 'C004', 88);
Insert Into score(stuid, courseno, scores) Values('1002', 'C004', 89);
Insert Into score(stuid, courseno, scores) Values('1003', 'C004', 90);
Insert Into score(stuid, courseno, scores) Values('1004', 'C004', 91);
Insert Into score(stuid, courseno, scores) Values('1005', 'C004', 92);
Insert Into score(stuid, courseno, scores) Values('1006', 'C004', 93);
Insert Into score(stuid, courseno, scores) Values('1001', 'C005', 77);
Insert Into score(stuid, courseno, scores) Values('1002', 'C005', 78);
Insert Into score(stuid, courseno, scores) Values('1003', 'C005', 79);
Insert Into score(stuid, courseno, scores) Values('1004', 'C005', 80);
Insert Into score(stuid, courseno, scores) Values('1005', 'C005', 81);
Insert Into score(stuid, courseno, scores) Values('1006', 'C005', 82);
Insert Into score(stuid, courseno, scores) Values('1001', 'C006', 77);
Insert Into score(stuid, courseno, scores) Values('1002', 'C006', 78);
Insert Into score(stuid, courseno, scores) Values('1003', 'C006', 79);
Insert Into score(stuid, courseno, scores) Values('1004', 'C006', 80);
Insert Into score(stuid, courseno, scores) Values('1005', 'C006', 81);
Insert Into score(stuid, courseno, scores) Values('1006', 'C006', 82);
为什么要行转列
这是我们进行成绩查询的时候看到的这种纵列的结果，但是一般的时候，我们想要看到下图这种结果
那么需要这样的结果就要进行行转列来操作了。
怎么行转列
像得到上图的结果，一般的行转列，我们只需要这么做
静态行转列
Select st.stuid, st.stunm,
MAX(CASE c.coursenm WHEN '大学语文' THEN s.scores ELSE 0 END ) '大学语文',
MAX(CASE c.coursenm WHEN '新视野英语' THEN ifnull(s.scores,0) ELSE 0 END ) '新视野英语',
MAX(CASE c.coursenm WHEN '离散数学' THEN ifnull(s.scores,0) ELSE 0 END ) '离散数学',
MAX(CASE c.coursenm WHEN '概率论与数理统计' THEN ifnull(s.scores,0) ELSE 0 END ) '概率论与数理统计',
MAX(CASE c.coursenm WHEN '线性代数' THEN ifnull(s.scores,0) ELSE 0 END ) '线性代数',
MAX(CASE c.coursenm WHEN '高等数学(一)' THEN ifnull(s.scores,0) ELSE 0 END ) '高等数学(一)',
MAX(CASE c.coursenm WHEN '高等数学(二)' THEN ifnull(s.scores,0) ELSE 0 END ) '高等数学(二)'
From Student st
Left Join score s On st.stuid = s.stuid
Left Join courses c On c.courseno = s.courseno
Group by st.stuid
看上面的语句可以看出，我们是在知道固定的几门课程之后，可以使用
MAX(CASE c.coursenm WHEN '线性代数' THEN ifnull(s.scores,0) ELSE 0 END ) '线性代数',
这样的语句来实现行转列
但我们都知道，课程不仅仅这几门，如果用上面的语句去写，第一要确定有多少课程，这么多课程的课程名要再拿出来，那样的话写一个查询语句下来，可是要写很多了。那么就想能不能动态进行行转列的操作？答案当然是肯定的了！
动态行转列
那么如何进行动态行转列呢？
首先我们要动态获取这样的语句
MAX(CASE c.coursenm WHEN '大学语文' THEN s.scores ELSE 0 END ) '大学语文',
MAX(CASE c.coursenm WHEN '线性代数' THEN ifnull(s.scores,0) ELSE 0 END ) '线性代数',
MAX(CASE c.coursenm WHEN '离散数学' THEN ifnull(s.scores,0) ELSE 0 END ) '离散数学'
而不是像上面那样一句句写出来，那如何得到这样的语句呢？
这里就要用到SQL语句拼接了。具体就是下面的语句
GROUP_CONCAT(DISTINCT
'MAX(IF(c.coursenm = ''',
c.coursenm,
''', s.scores, 0)) AS ''',
c.coursenm, ''''
得到的结果就是
MAX(IF(c.coursenm = '大学语文', s.scores, 0)) AS '大学语文',
MAX(IF(c.coursenm = '新视野英语', s.scores, 0)) AS '新视野英语',
MAX(IF(c.coursenm = '离散数学', s.scores, 0)) AS '离散数学',
MAX(IF(c.coursenm = '概率论与数理统计', s.scores, 0)) AS '概率论与数理统计',
MAX(IF(c.coursenm = '线性代数', s.scores, 0)) AS '线性代数',
MAX(IF(c.coursenm = '高等数学(一)', s.scores, 0)) AS '高等数学(一)',
MAX(IF(c.coursenm = '高等数学(二)', s.scores, 0)) AS '高等数学(二)'
对，没错，就是我们上面进行行转列查询要用的语句，那样就不用知道多少课程和这些课程的名字，只要这样几行代码便可以得到动态的列了。
动态的列是拿到了，那如何再结合SQL语句进行查询得到结果呢？
这里要说明一点，因为用到了拼接函数，如果像上面的查询语句，只是把那几行语句替换掉，也就是下面这样
Select st.stuid, st.stunm,
GROUP_CONCAT(DISTINCT
'MAX(IF(c.coursenm = ''',
c.coursenm,
''', s.scores, NULL)) AS ',
c.coursenm
FROM courses c
From Student st
Left Join score s On st.stuid = s.stuid
Left Join courses c On c.courseno = s.courseno
Group by st.
然而得到的结果却是这样的
这里我就不多做赘述了，想必大家也明白。那么既然这样不行，那该怎么做呢？
没错，这里就要像普通的那些语句那样，进行声明，将语句拼接完整之后，再执行，也就是下面这样
SET @sql = NULL;
GROUP_CONCAT(DISTINCT
'MAX(IF(c.coursenm = ''',
c.coursenm,
''', s.scores, 0)) AS ''',
c.coursenm, ''''
) INTO @sql
SET @sql = CONCAT('Select st.stuid, st.stunm, ', @sql,
' From Student st
Left Join score s On st.stuid = s.stuid
Left Join courses c On c.courseno = s.courseno
Group by st.stuid');
PREPARE stmt FROM @
DEALLOCATE PREPARE
直接执行这些语句，得到如下结果。
没错，和开始的时候那种全部拼出来的语句一样，这样就实现了动态行转列的目的了。而且我们不用知道多少课程，也无需把这些课程名一一列出来。
当然这个语句拼接中的查询可以加入条件查询，比如我们要查询学号是1003的成绩
也就是下面这样
语句则如下
SET @sql = NULL;
SET @stuid = '1003';
GROUP_CONCAT(DISTINCT
'MAX(IF(c.coursenm = ''',
c.coursenm,
''', s.scores, 0)) AS ''',
c.coursenm, ''''
) INTO @sql
SET @sql = CONCAT('Select st.stuid, st.stunm, ', @sql,
' From Student st
Left Join score s On st.stuid = s.stuid
Left Join courses c On c.courseno = s.courseno
Where st.stuid = ''', @stuid, '''
Group by st.stuid');
PREPARE stmt FROM @
DEALLOCATE PREPARE
对比前面的语句，我们可以看到在第二行的Left join后面我改了一些，还有就是前面的变量加了一个@stuid [ 注：这里的 @ 符号是在SQL语句定义变量习惯用法，我个人理解应该是用来区分吧！]
那么问题来了，行转列的查询已经实现了，怎么标题中还写着存储过程？对，没错，就是存储过程！
像上面的语句，我们如果直接在MySQL中操作是没问题的，但如果用到项目中，那么这个语句显然我们没法用，而且我这次做的项目是结合使用MyBatis，大家都知道在MyBatis中的XML文件中可以自己写SQL语句，但是这样的很显然我们没法放到XML文件中。
而且最关键的是，这里不能用 If 条件，好比我们要判断学号是否为空或者等于0再加上条件进行查询，可是这里不支持。
没错就是下面这样
SET @sql = NULL;
SET @stuid = '1003';
SET @courseno = 'C002';
GROUP_CONCAT(DISTINCT
'MAX(IF(c.coursenm = ''',
c.coursenm,
''', s.scores, 0)) AS ''',
c.coursenm, ''''
) INTO @sql
SET @sql = CONCAT('Select st.stuid, st.stunm, ', @sql,
' From Student st
Left Join score s On st.stuid = s.stuid
Left Join courses c On c.courseno = s.courseno');
IF @stuid is not null and @stuid != 0 then
SET @sql = CONCAT(@sql, ' Where st.stuid = ''', @stuid, '''');
SET @sql = CONCAT(@sql, ' Group by st.stuid');
PREPARE stmt FROM @
DEALLOCATE PREPARE
对，我就是加上 if 之后人家就是不支持，就是这么任性。
所以就要用到存储过程啦，而且用存储过程的好处是，方便我们调用，相当于一个函数，其他可能也是类似的查询不需再重复写代码，直接调存储过程就好，还能随心所欲的加上if条件判断，多么美好的事情，哈哈~。
那么说到存储过程，这里该如何写呢？
创建存储过程的语句我就不多写了，这里呢把上面的查询语句直接放到创建存储过程的begin和end直接就可以了，如下：
DELIMITER &&
drop procedure if exists SP_QueryD
Create Procedure SP_QueryData(IN stuid varchar(16))
READS SQL DATA
SET @sql = NULL;
SET @stuid = NULL;
GROUP_CONCAT(DISTINCT
'MAX(IF(c.coursenm = ''',
c.coursenm,
''', s.scores, 0)) AS ''',
c.coursenm, '\''
) INTO @sql
SET @sql = CONCAT('Select st.stuid, st.stunm, ', @sql,
' From Student st
Left Join score s On st.stuid = s.stuid
Left Join courses c On c.courseno = s.courseno');
IF stuid is not null and stuid && '' then
SET @stuid =
SET @sql = CONCAT(@sql, ' Where st.stuid = \'', @stuid, '\'');
SET @sql = CONCAT(@sql, ' Group by st.stuid');
PREPARE stmt FROM @
DEALLOCATE PREPARE
DELIMITER ;
嗯，对比上面简单的SQL语句可以看出，这里使用了 if 语句，对学号进行了判断
不过这里要注意一点，这里的if语句不像我们平时java啊那种写法也就是下面
&&& 要执行的语句块
对，在SQL里面的if语句不一样，不需要括号啊什么的，就像直接说英文一样
IF @stuid is not null and @stuid != 0 then
SET @sql = CONCAT(@sql, ' Where st.stuid = ''', @stuid, '''');
&嗯，就是这么简单明了，如果条件满足，那么就怎么样，然后结束。
然后我们就可以传参数调用这个SP了
CALL `SP_QueryData`('1001');
得到如下结果
当然我们也可以直接传个空串过去
CALL `SP_QueryData`('');
同样得到我们想要的结果
好了，以上就是这次我在MySQL进行动态行转列的实现过程。
总结及问题
开始的时候，只想到要行转列，写着写着突然发现要动态的，因为我不确定到底有多少列。
在网上各种找资料，然而看不太懂！
后来，参考了Pivot table with dynamic columns in MySQL这个，才写出来的。
然后是各种问题，先是SQL语句中加入if条件，我像平时写java那样，发现并没有什么用，网上也说就是这种
IF(stuid is not null && stuid && '') then
SET @stuid =
SET @sql = CONCAT(@sql, ' Where st.stuid = \'', @stuid, '\'');
可是我这么写了之后并没有什么用，还是报错，找了不少之后才发现原来不是这么写的，然后改了过来。
改完之后我以为可以了，可是，发现依旧不行。然后我就在想是不是这里不能用if判断，因为不是一个function或者procedure，于是我就写创建procedure的语句。
改造完之后，procedure成功的创建了。那创建完我就试试能不能，调用procedure之后，当当当当，结果出来了。
嗯，这个过程还是收获很多的，对MySQL的行转列，以及存储过程，还有在SQL语句中的使用不一样的地方等。
而且，这个行转列的实现了之后，这个项目基本上没啥大问题了对数据的处理，相当好啊，哈哈~
以上就是我在行转列实现的过程中所有的内容，相对来说，我觉得，这里写的很清楚很明了了，所以只要你有耐心看完并认真研究的话，这个内容对你的行转列还是有很大裨益的。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具