Oracle SQL INSERT语句转存储过程

我就是我 2023-02-20 12:12 5阅读 0赞

Oracle的CLOB或者是BLOB类型的字段，如果直接插入字符串，而且字符串的长度大于4000的话，总是会报错。  
网上找了有一种可行的方案是创建存储过程，定义变量去替换原来的字符串。但是只适合单条的情况，比如说我有一堆sql文件，但是因为这个原因执行不了，手敲的话根本就不可能完成。  
所以利用Druid的SqlParser API完成了这个脚本，可以自动完成转换。

package com.shy;
    
    import com.alibaba.druid.sql.ast.SQLExpr;
    import com.alibaba.druid.sql.ast.SQLStatement;
    import com.alibaba.druid.sql.ast.expr.SQLCharExpr;
    import com.alibaba.druid.sql.ast.expr.SQLVariantRefExpr;
    import com.alibaba.druid.sql.ast.statement.SQLInsertStatement;
    import com.alibaba.druid.sql.dialect.oracle.ast.stmt.OracleInsertStatement;
    import com.alibaba.druid.sql.dialect.oracle.parser.OracleStatementParser;
    import org.junit.Test;
    import java.util.ArrayList;
    import java.util.List;
    
    public class SqlParserDemo {
        
    
        /**
         * 解析sql语句,创建存储过程字符串
         * @param sqlStatement Druid提供的SQLStatement对象
         * @return  {String}存储过程
         * */
        private static String parseSqlStatement(SQLStatement sqlStatement){
        
            String varPreffix = "VAR_";//变量的前缀，为了和列名区分开来，可以自定义
            OracleInsertStatement insert = (OracleInsertStatement) sqlStatement;
            String tableName = insert.getTableName().toString();//获取表名
            List<SQLExpr> values = insert.getValues().getValues();//获取数据集合
            StringBuilder sb = new StringBuilder("DECLARE\n");//返回sql语句主体部分
            List<SQLExpr> columns = insert.getColumns();//获取所有列
            StringBuilder sb2 = new StringBuilder();//返回sql语句中的变量赋值语句
            for (int i = 0; i < values.size(); i++) {
        
                if(values.get(i) instanceof SQLCharExpr){
        //字符类型
                    String str = values.get(i).toString();
                    if(str.length() >= 4000){
        //长度大于4000
                        String columnName = columns.get(i).toString();//获取对应的列名
                        String varName = varPreffix + columnName;
                        sb.append(varName)
                                .append(" ")
                                .append(tableName)
                                .append(".")
                                .append(columnName)
                                .append("%TYPE;\n");//拼接变量定义语句
                        values.set(i,new SQLVariantRefExpr(varName));//替换数据中的长字符串为变量引用
                        sb2.append(varName)
                                .append(" := ")
                                .append(str)
                                .append(";\n");//拼接变量赋值语句
                    }
                }
            }
            sb.append("BEGIN\n")
                    .append(sb2)
                    .append("INSERT INTO ")
                    .append(tableName)
                    .append(" ( ");
            for(int i = 0; i < columns.size(); i++) {
        //拼接列名，这里好像没有官方的API，只能手动拼逗号
                if (i < columns.size() - 1)
                    sb.append(columns.get(i).toString())
                            .append(",");
                else
                    sb.append(columns.get(i).toString());
            }
            SQLInsertStatement.ValuesClause valuesClause = new SQLInsertStatement.ValuesClause(new ArrayList<>(values));//把集合中的数据组装起来
            sb.append(" ) ")
                    .append(valuesClause.toString())
                    .append(";\nCOMMIT;\nEND;\n");
            return sb.toString();
        }
    
        /**
         * 解析处理单条sql语句
         * */
        private static String convertSingleSql(String sql){
        
            OracleStatementParser parser = new OracleStatementParser(sql);
            SQLStatement statement = parser.parseStatement();
            return parseSqlStatement(statement);
        }
    
        /**
         * 解析处理多条sql语句
         * */
        private static String convertGroupSql(String sql){
        
            OracleStatementParser parser = new OracleStatementParser(sql);
            List<SQLStatement> sqlStatements = parser.parseStatementList();
            StringBuilder sb = new StringBuilder();
            for (SQLStatement sqlStatement : sqlStatements) {
        
                String promptSql = parseSqlStatement(sqlStatement);
                sb.append(promptSql).append("/\n\n");//存储过程分隔符要用/
            }
            return sb.toString();
        }
    
        @Test
        public void singleSqlTest(){
        
            String sql = "这里替换为要处理的单条sql语句";
            String promptSql = convertSingleSql(sql);
            System.out.println(promptSql);
        }
    
        @Test
        public void groupSqlTest(){
        
            String sql = "这里替换为要处理的多条sql语句";
            String sqlStr = convertGroupSql(sql);
            System.out.println(sqlStr);//输出最终的sql语句
        }
    }

转换完成的效果如下

DECLARE  
      VAR_BLOB_TEXT DEMO.BLOB_TEXT%TYPE;
    BEGIN  
      VAR_BLOB_TEXT := '这里是要插入的字符串，长度可以大于4000'; --字段内容
      INSERT　INTO　DEMO VALUES(1,'xxx','xxx',VAR_BLOB_TEXT);
      COMMIT;  
    END;