JSqlParser解析JSON数据类型：MySQL与PostgreSQL实现对比

JSqlParser解析JSON数据类型：MySQL与PostgreSQL实现对比

【免费下载链接】JSqlParser JSQLParser/JSqlParser: 这是一个用于解析和执行SQL语句的Java库。适合用于需要解析和执行SQL语句的场景。特点：易于使用，支持多种数据库的SQL语句解析和执行，具有灵活的语句构建和解析功能。 项目地址: https://gitcode.com/gh_mirrors/js/JSqlParser

引言：JSON数据类型解析的跨数据库挑战

你是否在开发跨数据库应用时遭遇过JSON语法解析的兼容性难题？当MySQL的JSON_OBJECT('name', 'Alice')遇上PostgreSQL的JSON_BUILD_OBJECT('name', 'Alice')，传统字符串处理方式往往导致代码臃肿不堪。JSqlParser作为Java生态中最成熟的SQL解析库，通过统一抽象层解决了这一痛点。本文将深入剖析JSqlParser如何实现MySQL与PostgreSQL JSON数据类型的解析适配，帮助开发者构建真正跨数据库的JSON处理逻辑。

读完本文你将掌握：

• JSqlParser JSON解析核心类的设计原理
• MySQL与PostgreSQL JSON语法的解析差异对比
• 跨数据库JSON操作的统一处理策略
• 高级JSON函数解析的实现方式

JSqlParser JSON解析架构概览

核心类层次结构

JSqlParser采用面向接口的设计模式，构建了灵活的JSON解析体系：

核心组件功能说明：

• JsonExpression：处理JSON路径表达式（如->、->>操作符）
• JsonFunction：解析JSON构造函数（如JSON_OBJECT、JSON_ARRAY）
• JsonFunctionType：枚举数据库特有的JSON函数类型

解析流程时序图

MySQL JSON解析实现

语法特征与解析规则

MySQL采用键值对列表形式定义JSON对象，如JSON_OBJECT('key', value, ...)。JSqlParser通过JsonFunctionType.MYSQL_OBJECT类型专门处理此类语法：

// JsonFunction.java
private StringBuilder appendMySqlObject(StringBuilder builder) {
    builder.append("JSON_OBJECT( ");
    int i = 0;
    for (JsonKeyValuePair keyValuePair : keyValuePairs) {
        if (i > 0) {
            builder.append(", ");
        }
        builder.append(keyValuePair.getKey());
        builder.append(", ").append(keyValuePair.getValue());
        i++;
    }
    builder.append(" ) ");
    return builder;
}

实战案例：MySQL JSON对象解析

解析MySQL JSON_OBJECT函数的完整流程：

1. SQL输入：

SELECT JSON_OBJECT('id', user.id, 'name', user.name) AS user_json FROM users

2. JSqlParser处理：

// 解析表达式
JsonFunction jsonFunction = (JsonFunction) CCJSqlParserUtil.parseExpression(
    "JSON_OBJECT('id', user.id, 'name', user.name)"
);

// 验证解析结果
Assertions.assertEquals(JsonFunctionType.MYSQL_OBJECT, jsonFunction.getType());
Assertions.assertEquals(2, jsonFunction.getKeyValuePairs().size());
Assertions.assertEquals("'id'", jsonFunction.getKeyValuePair(0).getKey().toString());
Assertions.assertEquals("user.id", jsonFunction.getKeyValuePair(0).getValue().toString());

3. 生成SQL：

// 输出MySQL语法
System.out.println(jsonFunction.toString()); 
// 结果: JSON_OBJECT( 'id', user.id, 'name', user.name )

支持的MySQL JSON函数

JSqlParser实现了完整的MySQL JSON函数解析：

函数	解析类	测试用例
JSON_OBJECT	JsonFunction (MYSQL_OBJECT)	JsonFunctionTest.testObjectMySQL()
JSON_ARRAY	JsonFunction (ARRAY)	JsonFunctionTest.testArray()
JSON_EXTRACT	JsonExpression	PostgresTest.testJSonExpressionIssue1696()
JSON_ARRAYAGG	JsonAggregateFunction	JsonFunctionTest.testArrayAgg()

PostgreSQL JSON解析实现

语法特征与解析规则

PostgreSQL使用 colon 语法定义JSON键值对，如JSON_BUILD_OBJECT('key', value)或'{"key": value}'::json。JSqlParser通过JsonFunctionType.POSTGRES_OBJECT类型处理：

// JsonFunction.java
private StringBuilder appendPostgresObject(StringBuilder builder) {
    builder.append("JSON_OBJECT( ");
    for (JsonKeyValuePair keyValuePair : keyValuePairs) {
        builder.append(keyValuePair.getKey());
        if (keyValuePair.getValue() != null) {
            builder.append(", ").append(keyValuePair.getValue());
        }
    }
    builder.append(" ) ");
    return builder;
}

实战案例：PostgreSQL JSON解析

1. SQL输入：

SELECT JSON_BUILD_OBJECT('id', user.id, 'name', user.name) AS user_json FROM users

2. JSqlParser处理：

// 解析PostgreSQL JSON表达式
JsonExpression expr = (JsonExpression) CCJSqlParserUtil.parseExpression(
    "'{\"key\": \"value\"}'::json -> 'key'"
);

// 验证解析结果
Assertions.assertEquals(new StringValue("key"), 
    expr.getIdent(0).getKey());

3. 特殊操作符支持： PostgreSQL特有的->>操作符解析：

// 测试用例来自PostgresTest.testJSonOperatorIssue1571()
String sql = "select json_array_elements(into_sex_json)->>'name' from period_market";
PlainSelect select = (PlainSelect) CCJSqlParserUtil.parse(sql);
JsonExpression jsonExpr = (JsonExpression) ((SelectExpressionItem) select.getSelectItems().get(0)).getExpression();

// 验证JSON路径
Assertions.assertEquals(">>", jsonExpr.getIdentList().get(0).getValue());
Assertions.assertEquals("name", jsonExpr.getIdentList().get(0).getKey().toString());

支持的PostgreSQL JSON函数

函数	解析类	测试用例
JSON_BUILD_OBJECT	JsonFunction (POSTGRES_OBJECT)	JsonFunctionTest.testObject()
JSON_AGG	JsonAggregateFunction	JsonFunctionTest.testObjectAgg()
-> 操作符	JsonExpression	PostgresTest.testJSonExpressionIssue1696()
->> 操作符	JsonExpression	PostgresTest.testJSonOperatorIssue1571()

跨数据库JSON解析对比分析

语法差异对比表

功能	MySQL语法	PostgreSQL语法	JSqlParser统一表示
JSON对象构造	JSON_OBJECT('k1', v1, 'k2', v2)	JSON_BUILD_OBJECT('k1', v1, 'k2', v2)	JsonFunction(type=MYSQL_OBJECT/POSTGRES_OBJECT)
JSON数组构造	JSON_ARRAY(1, 2, 3)	JSON_BUILD_ARRAY(1, 2, 3)	JsonFunction(type=ARRAY)
JSON路径提取	json_col->'$.path'	json_col->'path'	JsonExpression(idents=[('path', '->')])
文本提取	json_col->>'$.path'	json_col->>'path'	JsonExpression(idents=[('path', '->>')])
聚合对象	JSON_OBJECTAGG(k, v)	JSONB_OBJECT_AGG(k, v)	JsonAggregateFunction

解析行为差异分析

1. 键值对处理：

   • MySQL：JSON_OBJECT('key', value)采用逗号分隔的键值对列表
   • PostgreSQL：JSON_OBJECT('key' VALUE value)使用VALUE关键字分隔

2. 空值处理： MySQL默认将NULL值转换为JSON null：

   // JsonFunction.appendMySqlObject()
   if (onNullType != null) {
       switch (onNullType) {
           case NULL:
               builder.append(" NULL ON NULL");
               break;
           case ABSENT:
               builder.append(" ABSENT ON NULL");
               break;
       }
   }
   

3. 唯一键约束： PostgreSQL支持WITH UNIQUE KEYS子句：

   // JsonFunction.appendObject()
   if (uniqueKeysType != null) {
       switch (uniqueKeysType) {
           case WITH:
               builder.append(" WITH UNIQUE KEYS");
               break;
           case WITHOUT:
               builder.append(" WITHOUT UNIQUE KEYS");
               break;
       }
   }
   

高级应用：跨数据库JSON处理策略

统一JSON构造函数实现

通过工厂模式封装数据库差异：

public class JsonFunctionFactory {
    public static JsonFunction createJsonObject(List<String> keys, List<Expression> values, DBType dbType) {
        JsonFunction function = new JsonFunction();
        
        // 设置数据库特定类型
        function.setType(dbType == DBType.MYSQL ? 
            JsonFunctionType.MYSQL_OBJECT : JsonFunctionType.POSTGRES_OBJECT);
            
        // 添加键值对
        for (int i = 0; i < keys.size(); i++) {
            JsonKeyValuePair pair = new JsonKeyValuePair(
                new StringValue(keys.get(i)), 
                values.get(i),
                dbType == DBType.POSTGRES, // PostgreSQL使用KEY/VALUE关键字
                dbType == DBType.POSTGRES
            );
            function.add(pair);
        }
        
        return function;
    }
}

使用示例：

// 创建MySQL风格JSON对象
JsonFunction mysqlJson = JsonFunctionFactory.createJsonObject(
    Arrays.asList("id", "name"),
    Arrays.asList(new Column("user.id"), new Column("user.name")),
    DBType.MYSQL
);

// 创建PostgreSQL风格JSON对象
JsonFunction pgJson = JsonFunctionFactory.createJsonObject(
    Arrays.asList("id", "name"),
    Arrays.asList(new Column("user.id"), new Column("user.name")),
    DBType.POSTGRES
);

JSON路径表达式处理

public class JsonPathProcessor {
    public static JsonExpression createJsonPath(Expression jsonColumn, String path, String operator, DBType dbType) {
        // 标准化路径格式
        String normalizedPath = dbType == DBType.MYSQL ? "$." + path : path;
        
        // 创建路径条目
        Map.Entry<Expression, String> pathEntry = new AbstractMap.SimpleEntry<>(
            new StringValue(normalizedPath), 
            operator
        );
        
        // 构建JsonExpression
        return new JsonExpression(jsonColumn, Collections.singletonList(pathEntry));
    }
}

测试验证策略

单元测试架构

JSqlParser为JSON解析提供了全面的测试覆盖：

src/test/java/net/sf/jsqlparser/expression/
├── JsonExpressionTest.java      // JSON路径表达式测试
├── JsonFunctionTest.java        // JSON函数解析测试
└── JsonAggregateFunctionTest.java // JSON聚合函数测试

src/test/java/net/sf/jsqlparser/statement/select/
└── PostgresTest.java            // PostgreSQL特定JSON测试

关键测试用例解析

MySQL JSON_OBJECT测试：

@Test
public void testObjectMySQL() throws JSQLParserException {
    TestUtils.assertSqlCanBeParsedAndDeparsed(
        "SELECT JSON_OBJECT('person', tp.person, 'account', tp.account) obj", 
        true
    );
}

PostgreSQL JSON操作符测试：

@Test
public void testJSonExpressionIssue1696() throws JSQLParserException {
    String sqlStr = "SELECT '{\"key\": \"value\"}'::json -> 'key' AS X";
    PlainSelect plainSelect = (PlainSelect) assertSqlCanBeParsedAndDeparsed(sqlStr, true);
    SelectItem<?> selectExpressionItem = plainSelect.getSelectItems().get(0);
    
    // 验证JSON路径解析结果
    Assertions.assertEquals(
        new StringValue("key"),
        selectExpressionItem.getExpression(JsonExpression.class).getIdent(0).getKey()
    );
}

结论与展望

JSqlParser通过精妙的抽象设计，成功实现了MySQL与PostgreSQL JSON数据类型的解析适配。核心设计亮点包括：

1. 类型枚举隔离：使用JsonFunctionType枚举清晰区分数据库特有实现
2. 访问者模式：通过ExpressionVisitor接口实现灵活的JSON表达式处理
3. 构建器模式：JsonFunction类的appendObject()方法实现数据库特定SQL生成

未来发展方向：

• 增强JSON Schema验证支持
• 添加更多数据库方言（如SQL Server FOR JSON语法）
• 优化大型JSON文档的解析性能

通过本文介绍的解析原理和适配策略，开发者可以构建真正跨数据库的JSON处理逻辑，有效降低多数据库支持的开发成本。

参考资料

1. JSqlParser官方文档：src/site/sphinx/usage.rst
2. MySQL JSON函数文档：https://dev.mysql.com/doc/refman/8.0/en/json-functions.html
3. PostgreSQL JSON函数文档：https://www.postgresql.org/docs/current/functions-json.html
4. JSqlParser源码仓库：https://gitcode.com/gh_mirrors/js/JSqlParser

【免费下载链接】JSqlParser JSQLParser/JSqlParser: 这是一个用于解析和执行SQL语句的Java库。适合用于需要解析和执行SQL语句的场景。特点：易于使用，支持多种数据库的SQL语句解析和执行，具有灵活的语句构建和解析功能。 项目地址: https://gitcode.com/gh_mirrors/js/JSqlParser