数据库技术之存储过程设计与实现(三)
原创性声明
此博文的出处 为 http://blog.csdn.net/zhujunxxxxx/article/details/39251241如果进行转载请注明出处。本文作者原创,邮箱[email protected],如有问题请联系作者
一个java模拟的存储过程
在前两篇博客中介绍了存储过程的设计方法和数据结构。但是没有一个例子恐怕文章在好也没有很容易理解把
为此博主专门给了一个实例,我用java模拟了一个存储过程来实现,由于java下我没有进行词法语法解析,所以我的语法树就得自己来构造了(这真累)
我的所有表达式计算都是通过数据引擎计算的(其实很多数据库的存储过程都是这样的 比如postgresql)
先把给出我的数据结构
数据结构类
package java_test; import java.util.List; enum NodeType { t_none,t_var,t_stmt,t_create,t_declare,t_set,t_expr, t_if,t_elseif,t_when,t_case,t_while,t_for, t_exec,t_proc } enum DataType{ TT_INT,TT_CHAR,TT_BOOL,TT_DATE,TT_TIME,TT_APPROXNUM,TT_NULL,TT_VAR,TT_EXPR,TT_SIGN } class Node { int dno; NodeType node_type; } class VarNode extends Node{ String var_name; DataType data_type; int isconst; int notnull; String default_val;/*默认值*/ int isnull; String setvalue;/*赋值过后值*/ ExprNode expr_value; } class DeclareNode extends Node{ List<Node> var_list;/*这个declare语句所包含的变量*/ } class DeclNode extends Node{ /*定义存储过程的节点*/ String proc_name;/*存储过程名*/ List<Node> params;/*存储过程参数*/ } /*终结点*/ class ProcNode extends Node{ DeclNode declnode;/*定义存储过程的节点*/ List<Node> proc_body;/*存储过程的具体块,我觉得它有各种 if-else declare set sql when-case for while 构成的list*/ List<Node> except_list;/*异常列表*/ } class StmtNode extends Node{/*具体的一个sql语句节点*/ int sql_type; String str_sql; List<Node> params;/*此sql语句的参数*/ } class SetNode extends Node{ List<Node> var_list;/*这个set语句所包含的变量,和具体的值*/ } class ExprNode extends Node{ int is_const;/*是否是常量 -1 0 1*/ int is_wrap;/*是否有括号*/ DataType data_type;/*类型*/ String const_value;/*常量表达式的*/ String sign; String param; String str_value;/*无用*/ VarNode var_value;/*变量表达式的变量*/ ExprNode lnext; ExprNode rnext; } class IfNode extends Node{ ExprNode expr; List<Node> then_body; List<Node> elseif_body; List<Node> else_body; } class ElseIfNode extends Node{ ExprNode expr; List<Node> body; } class CaseNode extends Node{ ExprNode expr; List<Node> case_list; int have_else; List<Node> else_stmts; } class WhenNode extends Node{ ExprNode expr; List<Node> stmts; } class WhileNode extends Node{ ExprNode expr; List<Node> body; } class ForNode extends Node{ ExprNode lower; ExprNode upper; ExprNode step; List<Node> body; } class ProcExecState{ int dno; ProcNode proc; int rettype; Node lastnode; Node nextnode; String error; } class Dataum { DataType type; String value; boolean is_init; public Dataum(DataType t) { this.type=t; is_init=false; } public Dataum(DataType t,String v) { this.type=t; this.value=v; is_init=true; } }
这个类就是我们基本的数据结构
然后是一个解释器类,专门用来解释执行语法树的
解释器类
package java_test; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; enum ProcSQLState { PROC_SQL_RC_ERROR(0), PROC_SQL_RC_OK(1), PROC_SQL_RC_EXIT(2), PROC_SQL_RC_CONTINUE(3), PROC_SQL_RC_RETURN(4); private int nCode ; private ProcSQLState( int _nCode) { this . nCode = _nCode; } public int toInt() { return this.nCode; } @Override public String toString() { return String.valueOf (this.nCode ); } } public class language { public static MysqlHelper mysql=new MysqlHelper(); public static HashMap<String,Object> var_table =new HashMap<String,Object>(); public static int exec_stmts(ProcExecuteState estate,List<Node> stmts) { if(stmts==null) return 0; for (Node node : stmts) { int rc=exec_stmt(estate,node); if(rc==0) return 0; } return 1; } public static int exec_stmt(ProcExecuteState estate,Node stmt) { int rc=-1; switch(stmt.node_type) { case t_if: rc=exec_stmt_if(estate,(IfNode)stmt); break; case t_while: rc=exec_stmt_while(estate,(WhileNode)stmt); break; case t_case: rc=exec_stmt_case(estate,(CaseNode)stmt); break; case t_declare: rc=exec_stmt_declare(estate,(DeclareNode)stmt); break; case t_set: rc=exec_stmt_assign(estate,(SetNode)stmt); break; case t_stmt: rc=exec_stmt_sql(estate,(StmtNode)stmt); break; default: break; } return rc; } public static int exec_stmt_declare(ProcExecuteState estate,DeclareNode stmt) { for (Node node : stmt.var_list) { VarNode vnode=(VarNode)node; if(vnode.isconst!=1) { Dataum data=new Dataum(vnode.data_type); add_var(vnode.var_name,data); } } return 1; } public static int exec_stmt_assign(ProcExecuteState estate,SetNode stmt) { for (Node node : stmt.var_list) { VarNode vnode=(VarNode)node; if(vnode.isconst!=1) { set_value(vnode.var_name,vnode.expr_value); } } return 1; } public static int exec_stmt_if(ProcExecuteState estate,IfNode ifnode) { boolean value; value=exec_eval_bool(estate,ifnode.expr); if(value) return exec_stmts(estate,ifnode.then_body); for (Node item : ifnode.elseif_body) { ElseIfNode eifnode=(ElseIfNode)item; value=exec_eval_bool(estate,eifnode.expr); if(value) return exec_stmts(estate,eifnode.body); } return exec_stmts(estate, ifnode.else_body); } public static int exec_stmt_while(ProcExecuteState estate,WhileNode whilenode) { for(;;) { int rc; boolean value; value = exec_eval_bool(estate, whilenode.expr); if(!value) break; rc = exec_stmts(estate, whilenode.body); ProcSQLState erc=null; switch(rc) { case 0: erc=ProcSQLState.PROC_SQL_RC_ERROR; break; case 1: erc=ProcSQLState.PROC_SQL_RC_OK; break; case 2: erc=ProcSQLState.PROC_SQL_RC_EXIT; break; case 3: erc=ProcSQLState.PROC_SQL_RC_CONTINUE; break; case 4: erc=ProcSQLState.PROC_SQL_RC_RETURN; break; default: break; } switch(erc)//这里是while循环退出的地方 exit break return continue 等 有待完善 { case PROC_SQL_RC_OK: break; case PROC_SQL_RC_EXIT: break; case PROC_SQL_RC_CONTINUE: break; case PROC_SQL_RC_RETURN: break; default: break; } } return 1; } public static int exec_stmt_case(ProcExecuteState estate,CaseNode casenode) { ExprNode val=null; //case expr 的那个变量的值 接下来每一个whennode 的expr和它做比较 如果为真就执行,否则就不执行 if(casenode.expr!=null) { //val=exec_eval_expr(estate,casenode.expr); val=casenode.expr; //exec_assign_value 在这里给变量赋值 } for (Node item : casenode.case_list) { WhenNode whennode=(WhenNode)item; boolean value =exec_eval_compare(val,whennode.expr); if(value) { return exec_stmts(estate, whennode.stmts); } } if(casenode.have_else==1) { return exec_stmts(estate, casenode.else_stmts); } return 1; } public static int exec_stmt_sql(ProcExecuteState estate,StmtNode stmt) { return mysql.exec_update(stmt.str_sql); } //执行表达式,并返回结果 public static boolean exec_eval_bool(ProcExecuteState estate,ExprNode expr) { String sql=String.format("select %s", GetExprString(expr));//获取表达式字符串 return Integer.parseInt(mysql.exec(sql).toString())==1?true:false;//从数据库查询的到结果 } public static boolean exec_eval_compare(ExprNode expr1,ExprNode expr2) { String sql1=String.format("select %s", GetExprString(expr1));//获取表达式字符串 String ret1=mysql.exec(sql1).toString(); String sql2=String.format("select %s", GetExprString(expr2));//获取表达式字符串 String ret2=mysql.exec(sql2).toString(); return ret1.equals(ret2); } public static int exec_eval_int(ProcExecuteState estate,ExprNode expr) { String sql=String.format("select %s", GetExprString(expr)); return Integer.parseInt(mysql.exec(sql).toString()); } public static ExprNode exec_eval_expr(ProcExecuteState estate,ExprNode expr) { return null; } public static void add_var(String var_name,Dataum data) { if(!var_table.containsKey(var_name)) { var_table.put(var_name, data); } } public static void set_value(String var_name,Object value) { ExprNode v=(ExprNode)value; Dataum data; if(v.is_const==1)//是否常量 如果是常量就用常量值 否则就计算该表达式的值 data=new Dataum(v.data_type, v.const_value); else { String sql=String.format("select %s", GetExprString(v));//获取表达式字符串 String ret=mysql.exec(sql).toString();//从数据库查询的到结果 data=new Dataum(v.data_type, ret); } if(!var_table.containsKey(var_name)) { var_table.put(var_name, data); } else { var_table.remove(var_name); var_table.put(var_name, data); } } private static Dataum get_var_value(String var_name) { return (Dataum) var_table.get(var_name); } //获取该表达式节点的 字符串形式 还应该为里面的变量替换为真正的值 public static String expr_str=""; public static String GetExprString(ExprNode expr) { expr_str=""; InOrder(expr); return expr_str; } //中序遍历表达式 private static void InOrder(ExprNode expr) { if(expr==null) return; if(expr.is_wrap==1) expr_str+="("; InOrder(expr.lnext); if(expr.is_const==-1)//+ - * / % >>等 expr_str+=expr.sign; else if(expr.is_const==1) expr_str+=expr.const_value; else if(expr.is_const==0) { Dataum data=get_var_value(expr.var_value.var_name); if(data!=null) { expr_str+=data.value; } else { expr_str+=expr.var_value.var_name; System.out.println(expr.var_value.var_name+" 未赋值"); } } InOrder(expr.rnext); if(expr.is_wrap==1) expr_str+=")"; } public static void show_var() { Iterator iter = var_table.entrySet().iterator(); while(iter.hasNext()) { Map.Entry<String, Object> entry = (Map.Entry<String, Object>) iter.next(); String key = entry.getKey(); Dataum data=(Dataum)entry.getValue(); System.out.println(key+" "+data.value); } } }
可以看出来一个存储过程的执行基本上就是一个递归的过程
此博文的出处 为 http://blog.csdn.net/zhujunxxxxx/article/details/39251241如果进行转载请注明出处。本文作者原创,邮箱[email protected],如有问题请联系作者
作者简介
作者是一名软件工程出生的苦逼程序员,本科阶段也是软件工程,目前研究生在读,热爱新技术,热爱编程,为人幽默,热爱开源。
个人网站:http://www.zhujuncoding.com/
github: https://github.com/zhujunxxxxx/
郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。