sql里存json

① sql中对json数据字段的查询

先取出string，再在内存里转换为对象并检查。
ps：存json是没问题，但又想存json又想直接查，违反了数据库的范式。

② sqlite 可以存放json数据吗

sqlite 可以存放json数据
sqlite数据库中不支持布尔型。
SQLite将数据值的存储划分为以下几种存储类型：
NULL: 表示该值为NULL值。
INTEGER: 无符号整型值。
REAL: 浮点值。
TEXT: 文本字符串，存储使用的编码方式为UTF-8、UTF-16BE、UTF-16LE。
BLOB: 存储Blob数据，该类型数据和输入数据完全相同。
由于SQLite采用的是动态数据类型，而其他传统的关系型数据库使用的是静态数据类型，即字段可以存储的数据类型是在表声明时即以确定的，因此它们之间在数据存储方面还是存在着很大的差异。在SQLite中，存储分类和数据类型也有一定的差别，如INTEGER存储类别可以包含6种不同长度的Integer数据类型，然而这些INTEGER数据一旦被读入到内存后，SQLite会将其全部视为占用8个字节无符号整型。因此对于SQLite而言，即使在表声明中明确了字段类型，我们仍然可以在该字段中存储其它类型的数据。然而需要特别说明的是，尽管SQLite为我们提供了这种方便，但是一旦考虑到数据库平台的可移植性问题，我们在实际的开发中还是应该尽可能的保证数据类型的存储和声明的一致性。除非你有极为充分的理由，同时又不再考虑数据库平台的移植问题，在此种情况下确实可以使用SQLite提供的此种特征。

③ 如何将 JSON 对象存储在 SQLite 数据库中

将json对象的
键值对，转化为
ContentValues
对象中的键值对（键
为表中的字段名），然后插入数据库就可以了。
dbManager.insert(TABLENAME,
null,
values);
如果您对我的回答有不满意的地方，还请您继续追问；
答题不易，互相理解，互相帮助！

④ 怎么把json字符串存

1、假如json字符串的最大长度不会超过1024字节，那么我们可以定义表结构varchar(1024)。如下图，我们定义一个表t_save_json，有一个自增的id字段以及json字段保存json字符串。
2、如果json字符串中字符是双引号标记的，如{"name":"Q花荣","age":18,"a":"第一条信息"}。那么我们写sql语句保存到数据库时直接用引号括起来就行。如：insert into t_save_json set json = '{"name":"Q花荣","age":18,"a":"第一条信息"}';
3、如果json字符串中字符是单引号标记的，如{'name':'Q花荣','age':18,'a':'第二条信息'}。那么通常的做法需要对单引号进行转义，写sql语句时连续两个''表示单引号。如：insert into t_save_json set json = '{''name'':''Q花荣'',''age'':18,''a'':''第二条信息''}';
但笔者发现mysql中，sql中用双引号来标记json字符串也可以，一般比较少用，笔者也学习了。如：insert into t_save_json set json = "{'name':'Q花荣','age':18,'a':'第三条信息'}";
4、如果json字符串长度太大，那么我们建表时还是应该选择TEXT类型。TEXT采用字符存储，专门为存储大数据而设计。如下图，我们定义表t_save_json_2，json字段类型为TEXT，保存大字符串。
5、使用相同的sql语句，保存json字符串到表t_save_json_2中。

⑤ 第六章 SQL聚合函数 JSON_ARRAYAGG

创建 JSON 格式值数组的聚合函数。

注：IRIS可用，IRIS之前版本不可用。

JSON_ARRAYAGG 聚合函数返回指定列中值的JSON格式数组。

一个简单的 JSON_ARRAYAGG (或 JSON_ARRAYAGG ALL )返回一个 JSON 数组，其中包含所选行中 string-expr 的所有值。
字符串 -expr 为空字符串 (") 的行由数组中的( " u0000" )表示。
字符串 -expr 为NULL的行不包含在数组中。
如果只有一个字符串 -expr 值，并且是空字符串( " )， JSON_ARRAYAGG 将返回 JSON 数组 ["u0000"] 。
如果所有的 string-expr 值为 NULL , JSON_ARRAYAGG 返回一个空的 JSON 数组 [] 。

JSON_ARRAYAGG DISTINCT 返回一个 JSON 数组，由所选行中 string-expr 的所有不同(唯一)值组成: JSON_ARRAYAGG(DISTINCT col1) 。
NULL 字符串 -expr 不包含在 JSON 数组中。
JSON_ARRAYAGG(DISTINCT BY(col2) col1) 返回一个 JSON 数组，该数组只包含记录中 col2 值是不同的(唯一的)的那些 col1 字段值。
但是请注意，不同的 col2 值可能包含一个单独的 NULL 值。

JSON_ARRAYAGG string-expr 不能是流字段。
指定流字段的结果是 SQLCODE -37 。

默认的 JSON_ARRAYAGG 返回类型是 VARCHAR(8192) 。
这个长度包括 JSON 数组格式化字符以及字段数据字符。
如果预期返回的值将需要大于 8192 ，可以使用 CAST 函数指定一个更大的返回值。
例如 CAST(JSON_ARRAYAGG(value)) AS VARCHAR(12000)) 。
如果实际返回的JSON数组长于 JSON_ARRAYAGG 返回类型长度，IRIS将在返回类型长度处截断JSON数组，而不会发出错误。
因为截断JSON数组会删除其关闭的 ] 字符，这使得返回值无效。

可以使用 %SelectMode 属性为 JSON 数组中的元素指定数据显示值: 0=Logical (默认值)， 1=ODBC , 2= display 。
如果 string-expr 包含一个 %List 结构，则元素以ODBC模式表示，用逗号分隔，在逻辑和显示模式中以 %List 格式字符表示，用 转义序列表示。

JSON_ARRAYAGG 函数将表中多行列的值组合成一个包含元素值的 JSON 数组。
因为在计算所有聚合字段之后，查询结果集中应用了一个 ORDER BY 子句，所以 ORDER BY 不能直接影响这个列表中的值序列。
在某些情况下， JSON_ARRAYAGG 结果可能是按顺序出现的，但是不应该依赖于这种顺序。
在给定聚合结果值中列出的值不能显式排序。

下面的嵌入式SQL示例返回一个主机变量，该变量包含示例的 Home_State 列中所有值的 JSON 数组。
以字母 A 开头的人名表:

注意，这个 JSON 数组包含重复的值。

下面的动态SQL示例返回一个主机变量，该变量包含样本的 Home_State 列中所有不同(唯一)值的JSON数组。
以字母 A 开头的人名表:

下面的SQL示例为每个州创建了一个 JSON 数组，其中包含在 Home_City 列中找到的所有值，以及按州列出的这些城市值的计数。
每个 Home_State 行包含该状态的所有 Home_City 值的 JSON 数组。
这些JSON数组可能包含重复的城市名称:

更有用的是一个 JSON 数组的所有不同的值，发现在 Home_City 列为每个州，如下所示的动态SQL示例:

注意，这个示例返回每个州的不同城市名称和总城市名称的整数计数。

下面的动态SQL示例使用 %SelectMode 属性为 DOB 日期字段返回的JSON值数组指定 ODBC 显示模式:

下面的动态SQL示例使用 %FOREACH 关键字。
它为每个不同的 Home_State 返回一行，其中包含该 Home_State 的年龄值的JSON数组。

下面的动态SQL示例使用 %AFTERHAVING 关键字。
它为每个 Home_State 返回一行，其中至少包含一个满足 HAVING 子句条件的 Name 值(以 “M” 开头的名称)。
第一个 JSON_ARRAYAGG 函数返回一个包含该状态所有名称的 JSON 数组。
第二个 JSON_ARRAYAGG 函数返回的 JSON 数组只包含满足 HAVING 子句条件的名称:

⑥ mysql数据库中某个字段存的是json数据,如何对json数据中的数据进行操作

这个可以吧json格式的字符串解析成数组json_decode()函数，变成数组以后就可以方便操作了，可以删除数组中的任意一项，也可以增加一项比如：array_push($data,['sort'=>3,'catentryId'=>10003]),再变成json格式的存入数据库。方法有多种，这里简单的示例下

⑦ 怎么在mysql中放入json数据

我们知道，JSON是一种轻量级的数据交互的格式，大部分NO SQL数据库的存储都用JSON。MySQL从5.7开始支持JSON格式的数据存储，并且新增了很多JSON相关函数。MySQL 8.0 又带来了一个新的把JSON转换为TABLE的函数JSON_TABLE，实现了JSON到表的转换。

举例一

我们看下简单的例子：

简单定义一个两级JSON 对象

mysql> set @ytt='{"name":[{"a":"ytt","b":"action"}, {"a":"dble","b":"shard"},{"a":"mysql","b":"oracle"}]}';Query OK, 0 rows affected (0.00 sec)

第一级：

mysql> select json_keys(@ytt);+-----------------+| json_keys(@ytt) |+-----------------+| ["name"] |+-----------------+1 row in set (0.00 sec)

第二级：

mysql> select json_keys(@ytt,'$.name[0]');+-----------------------------+| json_keys(@ytt,'$.name[0]') |+-----------------------------+| ["a", "b"] |+-----------------------------+1 row in set (0.00 sec)

我们使用MySQL 8.0 的JSON_TABLE 来转换 @ytt。

• mysql> select * from json_table(@ytt,'$.name[*]' columns (f1 varchar(10) path '$.a', f2 varchar(10) path '$.b')) as tt;

• +-------+--------+

• | f1 | f2 |

• +-------+--------+

• | ytt | action |

• | dble | shard |

• | mysql | oracle |

• +-------+--------+

• 3 rows in set (0.00 sec)

举例二

再来一个复杂点的例子，用的是EXPLAIN 的JSON结果集。

JSON 串 @json_str1。

• set @json_str1 = ' { "query_block": { "select_id": 1, "cost_info": { "query_cost": "1.00" }, "table": { "table_name": "bigtable", "access_type": "const", "possible_keys": [ "id" ], "key": "id", "used_key_parts": [ "id" ], "key_length": "8", "ref": [ "const" ], "rows_examined_per_scan": 1, "rows_proced_per_join": 1, "filtered": "100.00", "cost_info": { "read_cost": "0.00", "eval_cost": "0.20", "prefix_cost": "0.00", "data_read_per_join": "176" }, "used_columns": [ "id", "log_time", "str1", "str2" ] } }}';




第一级：

• mysql> select json_keys(@json_str1) as 'first_object';+-----------------+| first_object |+-----------------+| ["query_block"] |+-----------------+1 row in set (0.00 sec)




第二级：

• mysql> select json_keys(@json_str1,'$.query_block') as 'second_object';+-------------------------------------+| second_object |+-------------------------------------+| ["table", "cost_info", "select_id"] |+-------------------------------------+1 row in set (0.00 sec)




第三级：

• mysql> select json_keys(@json_str1,'$.query_block.table') as 'third_object'G*************************** 1. row ***************************third_object: ["key","ref","filtered","cost_info","key_length","table_name","access_type","used_columns","possible_keys","used_key_parts","rows_examined_per_scan","rows_proced_per_join"]1 row in set (0.01 sec)




第四级：

• mysql> select json_extract(@json_str1,'$.query_block.table.cost_info') as 'forth_object'G*************************** 1. row ***************************forth_object: {"eval_cost":"0.20","read_cost":"0.00","prefix_cost":"0.00","data_read_per_join":"176"}1 row in set (0.00 sec)




那我们把这个JSON 串转换为表。

• SELECT * FROM JSON_TABLE(@json_str1,

• "$.query_block"

• COLUMNS(

• rowid FOR ORDINALITY,

• NESTED PATH '$.table'

• COLUMNS (

• a1_1 varchar(100) PATH '$.key',

• a1_2 varchar(100) PATH '$.ref[0]',

• a1_3 varchar(100) PATH '$.filtered',

• nested path '$.cost_info'

• columns (

• a2_1 varchar(100) PATH '$.eval_cost' ,

• a2_2 varchar(100) PATH '$.read_cost',

• a2_3 varchar(100) PATH '$.prefix_cost',

• a2_4 varchar(100) PATH '$.data_read_per_join'

• ),

• a3 varchar(100) PATH '$.key_length',

• a4 varchar(100) PATH '$.table_name',

• a5 varchar(100) PATH '$.access_type',

• a6 varchar(100) PATH '$.used_key_parts[0]',

• a7 varchar(100) PATH '$.rows_examined_per_scan',

• a8 varchar(100) PATH '$.rows_proced_per_join',

• a9 varchar(100) PATH '$.key'

• ),

• NESTED PATH '$.cost_info'

• columns (

• b1_1 varchar(100) path '$.query_cost'

• ),

• c INT path "$.select_id"

• )

• ) AS tt;

• +-------+------+-------+--------+------+------+------+------+------+----------+-------+------+------+------+------+------+------+

• | rowid | a1_1 | a1_2 | a1_3 | a2_1 | a2_2 | a2_3 | a2_4 | a3 | a4 | a5 | a6 | a7 | a8 | a9 | b1_1 | c |

• +-------+------+-------+--------+------+------+------+------+------+----------+-------+------+------+------+------+------+------+

• | 1 | id | const | 100.00 | 0.20 | 0.00 | 0.00 | 176 | 8 | bigtable | const | id | 1 | 1 | id | NULL | 1 |

• | 1 | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | NULL | 1.00 | 1 |

• +-------+------+-------+--------+------+------+------+------+------+----------+-------+------+------+------+------+------+------+

• 2 rows in set (0.00 sec)

当然，JSON_table 函数还有其他的用法，我这里不一一列举了，详细的参考手册。

⑧ sqlserver2008不支持json

sql server2008支持json函数
1。json 转化成数据集合
1）转化用函数
CREATE FUNCTION [dbo].[parseJSON]( @JSON NVARCHAR(MAX))

RETURNS @hierarchy TABL

element_id INT IDENTITY(1, 1) NOT NULL, /* internal surrogate primary key gives the order of parsing and the list order */

sequenceNo [int] NULL, /* the place in the sequence for the element */

parent_ID INT,/* if the element has a parent then it is in this column. The document is the ultimate parent, so you can get the structure from recursing from the document */

Object_ID INT,/* each list or object has an object id. This ties all elements to a parent. Lists are treated as objects here */

NAME NVARCHAR(2000),/* the name of the object */

StringValue NVARCHAR(MAX) NOT NULL,/*the string representation of the value of the element. */

ValueType VARCHAR(10) NOT null /* the declared type of the value represented as a string in StringValue*/

)

AS

BEGIN

DECLARE

@FirstObject INT, --the index of the first open bracket found in the JSON string

@OpenDelimiter INT,--the index of the next open bracket found in the JSON string

@NextOpenDelimiter INT,--the index of subsequent open bracket found in the JSON string

@NextCloseDelimiter INT,--the index of subsequent close bracket found in the JSON string

@Type NVARCHAR(10),--whether it denotes an object or an array

@NextCloseDelimiterChar CHAR(1),--either a '}' or a ']'

@Contents NVARCHAR(MAX), --the unparsed contents of the bracketed expression

@Start INT, --index of the start of the token that you are parsing

@end INT,--index of the end of the token that you are parsing

@param INT,--the parameter at the end of the next Object/Array token

@EndOfName INT,--the index of the start of the parameter at end of Object/Array token

@token NVARCHAR(200),--either a string or object

@value NVARCHAR(MAX), -- the value as a string

@SequenceNo int, -- the sequence number within a list

@name NVARCHAR(200), --the name as a string

@parent_ID INT,--the next parent ID to allocate

@lenJSON INT,--the current length of the JSON String

@characters NCHAR(36),--used to convert hex to decimal

@result BIGINT,--the value of the hex symbol being parsed

@index SMALLINT,--used for parsing the hex value

@Escape INT --the index of the next escape character

DECLARE @Strings TABLE /* in this temporary table we keep all strings, even the names of the elements, since they are 'escaped' in a different way, and may contain, unescaped, brackets denoting objects or lists. These are replaced in the JSON string by tokens representing the string */

(

String_ID INT IDENTITY(1, 1),

StringValue NVARCHAR(MAX)

)

SELECT--initialise the characters to convert hex to ascii

@characters='',

@SequenceNo=0, --set the sequence no. to something sensible.

/* firstly we process all strings. This is done because [{} and ] aren't escaped in strings, which complicates an iterative parse. */

@parent_ID=0;

WHILE 1=1 --forever until there is nothing more to do

BEGIN

SELECT

@start=PATINDEX('%[^a-zA-Z]["]%', @json collate SQL_Latin1_General_CP850_Bin);--next delimited string

IF @start=0 BREAK --no more so drop through the WHILE loop

IF SUBSTRING(@json, @start+1, 1)='"'

BEGIN --Delimited Name

SET @start=@Start+1;

SET @end=PATINDEX('%[^\]["]%', RIGHT(@json, LEN(@json+'|')-@start));

END

IF @end=0 --no end delimiter to last string

BREAK --no more

SELECT @token=SUBSTRING(@json, @start+1, @end-1)

--now put in the escaped control characters

SELECT @token=REPLACE(@token, FROMString, TOString)

FROM

(SELECT

'\"' AS FromString, '"' AS ToString

UNION ALL SELECT '\\', '\'

UNION ALL SELECT '\/', '/'

UNION ALL SELECT '\b', CHAR(08)

UNION ALL SELECT '\f', CHAR(12)

UNION ALL SELECT '\n', CHAR(10)

UNION ALL SELECT '\r', CHAR(13)

UNION ALL SELECT '\t', CHAR(09)

) substitutions

SELECT @result=0, @escape=1

--Begin to take out any hex escape codes

WHILE @escape>0

BEGIN

SELECT @index=0,

--find the next hex escape sequence

@escape=PATINDEX('%\x[0-9a-f][0-9a-f][0-9a-f][0-9a-f]%', @token)

IF @escape>0 --if there is one

BEGIN

WHILE @index<4 --there are always four digits to a \x sequence

BEGIN

SELECT --determine its value

@result=@result+POWER(16, @index)

*(CHARINDEX(SUBSTRING(@token, @escape+2+3-@index, 1),

@characters)-1), @index=@index+1 ;

END

-- and replace the hex sequence by its unicode value

SELECT @token=STUFF(@token, @escape, 6, NCHAR(@result))

END

END

--now store the string away

INSERT INTO @Strings (StringValue) SELECT @token

-- and replace the string with a token

SELECT @JSON=STUFF(@json, @start, @end+1,

'@string'+CONVERT(NVARCHAR(5), @@identity))

END

-- all strings are now removed. Now we find the first leaf.

WHILE 1=1 --forever until there is nothing more to do

BEGIN

SELECT @parent_ID=@parent_ID+1

--find the first object or list by looking for the open bracket

SELECT @FirstObject=PATINDEX('%[{[[]%', @json collate SQL_Latin1_General_CP850_Bin)--object or array

IF @FirstObject = 0 BREAK

IF (SUBSTRING(@json, @FirstObject, 1)='{')

SELECT @NextCloseDelimiterChar='}', @type='object'

ELSE

SELECT @NextCloseDelimiterChar=']', @type='array'

SELECT @OpenDelimiter=@firstObject

WHILE 1=1 --find the innermost object or list...

BEGIN

SELECT

@lenJSON=LEN(@JSON+'|')-1

--find the matching close-delimiter proceeding after the open-delimiter

SELECT

@NextCloseDelimiter=CHARINDEX(@NextCloseDelimiterChar, @json,

@OpenDelimiter+1)

--is there an intervening open-delimiter of either type

SELECT @NextOpenDelimiter=PATINDEX('%[{[[]%',

RIGHT(@json, @lenJSON-@OpenDelimiter)collate SQL_Latin1_General_CP850_Bin)--object

IF @NextOpenDelimiter=0

BREAK

SELECT @NextOpenDelimiter=@NextOpenDelimiter+@OpenDelimiter

IF @NextCloseDelimiter<@NextOpenDelimiter

BREAK

IF SUBSTRING(@json, @NextOpenDelimiter, 1)='{'

SELECT @NextCloseDelimiterChar='}', @type='object'

ELSE

SELECT @NextCloseDelimiterChar=']', @type='array'

SELECT @OpenDelimiter=@NextOpenDelimiter

END

---and parse out the list or name/value pairs

SELECT

@contents=SUBSTRING(@json, @OpenDelimiter+1,

@NextCloseDelimiter-@OpenDelimiter-1)

SELECT

@JSON=STUFF(@json, @OpenDelimiter,

@NextCloseDelimiter-@OpenDelimiter+1,

'@'+@type+CONVERT(NVARCHAR(5), @parent_ID))

WHILE (PATINDEX('%[A-Za-z0-9@+.e]%', @contents collate SQL_Latin1_General_CP850_Bin))<>0

BEGIN

IF @Type='Object' --it will be a 0-n list containing a string followed by a string, number,boolean, or null

BEGIN

SELECT

@SequenceNo=0,@end=CHARINDEX(':', ' '+@contents)--if there is anything, it will be a string-based name.

SELECT @start=PATINDEX('%[^A-Za-z@][@]%', ' '+@contents)--AAAAAAAA

SELECT @token=SUBSTRING(' '+@contents, @start+1, @End-@Start-1),

@endofname=PATINDEX('%[0-9]%', @token collate SQL_Latin1_General_CP850_Bin),

@param=RIGHT(@token, LEN(@token)-@endofname+1)

SELECT

@token=LEFT(@token, @endofname-1),

@Contents=RIGHT(' '+@contents, LEN(' '+@contents+'|')-@end-1)

SELECT @name=stringvalue FROM @strings

WHERE string_id=@param --fetch the name

END

ELSE

SELECT @Name=null,@SequenceNo=@SequenceNo+1

SELECT

@end=CHARINDEX(',', @contents)-- a string-token, object-token, list-token, number,boolean, or null

IF @end=0

SELECT @end=PATINDEX('%[A-Za-z0-9@+.e][^A-Za-z0-9@+.e]%', @Contents+' ')

+1

SELECT

@start=PATINDEX('%[^A-Za-z0-9@+.e][A-Za-z0-9@+.e]%', ' '+@contents)

--select @start,@end, LEN(@contents+'|'), @contents

SELECT

@Value=RTRIM(SUBSTRING(@contents, @start, @End-@Start)),

@Contents=RIGHT(@contents+' ', LEN(@contents+'|')-@end)

IF SUBSTRING(@value, 1, 7)='@object'

INSERT INTO @hierarchy

(NAME, SequenceNo, parent_ID, StringValue, Object_ID, ValueType)

SELECT @name, @SequenceNo, @parent_ID, SUBSTRING(@value, 8, 5),

SUBSTRING(@value, 8, 5), 'object'

ELSE

IF SUBSTRING(@value, 1, 6)='@array'

INSERT INTO @hierarchy

(NAME, SequenceNo, parent_ID, StringValue, Object_ID, ValueType)

SELECT @name, @SequenceNo, @parent_ID, SUBSTRING(@value, 7, 5),

SUBSTRING(@value, 7, 5), 'array'

ELSE

IF SUBSTRING(@value, 1, 7)='@string'

INSERT INTO @hierarchy

(NAME, SequenceNo, parent_ID, StringValue, ValueType)

SELECT @name, @SequenceNo, @parent_ID, stringvalue, 'string'

FROM @strings

WHERE string_id=SUBSTRING(@value, 8, 5)

ELSE

IF @value IN ('true', 'false')

INSERT INTO @hierarchy

(NAME, SequenceNo, parent_ID, StringValue, ValueType)

SELECT @name, @SequenceNo, @parent_ID, @value, 'boolean'

ELSE

IF @value='null'

INSERT INTO @hierarchy

(NAME, SequenceNo, parent_ID, StringValue, ValueType)

SELECT @name, @SequenceNo, @parent_ID, @value, 'null'

ELSE

IF PATINDEX('%[^0-9]%', @value collate SQL_Latin1_General_CP850_Bin)>0

INSERT INTO @hierarchy

(NAME, SequenceNo, parent_ID, StringValue, ValueType)

SELECT @name, @SequenceNo, @parent_ID, @value, 'real'

ELSE

INSERT INTO @hierarchy

(NAME, SequenceNo, parent_ID, StringValue, ValueType)

SELECT @name, @SequenceNo, @parent_ID, @value, 'int'

if @Contents=' ' Select @SequenceNo=0

END

END

INSERT INTO @hierarchy (NAME, SequenceNo, parent_ID, StringValue, Object_ID, ValueType)

SELECT '-',1, NULL, '', @parent_id-1, @type

--

RETURN

END

2.举例

Select * from parseJSON('{
"联系人":
{
"姓名": "huang",
"网名": "HTL",
"AGE": 05,
"男人":true,
"PhoneNumbers":
{
"mobile":"135123100514",
"phone":"0251-123456789"
}

}
}
')

以上用到函数，转自：http://blog.csdn.net/ghlfllz/article/details/51649837#

二、sql转化成json、xml等方法
见链接：http://www.cnblogs.com/huangtailang/p/4277809.html

原文链接：https://www.simple-talk.com/sql/t-sql-programming/consuming-json-strings-in-sql-server/

三、sqlserver2016支持json
请看：https://msdn.microsoft.com/en-us/library/dn921897.aspx

SELECT Name, Surname,
JSON_VALUE(jsonCol, '$.info.address.PostCode') as PostCode,
JSON_VALUE(jsonCol, '$.info.address."Address Line 1"') + ' ' + JSON_VALUE(jsonCol, '$.info.address."Address Line 2"') AS Address,
JSON_QUERY(jsonCol, '$.info.skills') as Skills
FROM PeopleCollection
WHERE ISJSON(jsonCol) > 0
AND JSON_VALUE(jsonCol, '$.info.address.town') = 'Belgrade'
AND Status = 'Active'
ORDER BY JSON_VALUE(@jsonInfo, '$.info.address.PostCode')
文章知识点与官方知识档案匹配
MySQL入门技能树内置函数JSON函数
29106 人正在系统学习中

⑨ 如何将拼凑的json串存入sqlserver中

先检查数据库中保存这个数据的字段的数据类型是否设置有误，这种大量字符的字段，数据类型可以使用text或者varchar(max),如果数据库的字段设置没有问题，请检查存储前的代码，是否有字符串截断操作。

⑩ JS 中使用 SQL 查询 JSON 数据

JsonSQL 可以方便的使用 sql 语句查询 json 数据。

示例：

源码很简洁 jsonsql-0.1.js ：

可以直接使用源码方式，demo地址：

http://files.cnblogs.com/zhangchen/JsonSQL.rar

也可以使用 npm 安装，地址：

https://www.npmjs.com/package/jsonsql