执行通用存储过程

最新推荐文章于 2024-04-30 17:28:01 发布
最新推荐文章于 2024-04-30 17:28:01 发布
阅读量240 收藏
点赞数
文章标签： java intellij-idea 开发语言 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44310866/article/details/129953981
版权

  • 创建jdbc工具类

jdbc.properties信息：

DriverClasses = com.microsoft.sqlserver.jdbc.SQLServerDriver

url = jdbc:sqlserver://192.168.166.129:1433;DatabaseName=datadb
user = sa
password = 123456
charset = ISO
maxconn = 300
minconn = 50
maxusecount = 6000
maxidletime = 600
maxalivetime = 10
checktime = 3600

ecology.isgoveproj = 0
LOG_FORMAT = yyyy.MM.dd'-'hh:mm:ss
DEBUG_MODE = false


jdbc工具类:

package com.api.login.web;

import java.io.FileReader;
import java.io.IOException;
import java.sql.*;
import java.util.Properties;
/**
* @ProjectName: HangDuProject
* @Package: com.api.ajk.impl
* @ClassName: JDBCUtils
* @Author: admin
* @Description: jdbc驱动类
* @Date: 2023/3/9 16:31
* @Version: 1.0
*/
public class JDBCUtils {
    private static String url;
    private static String user;
    private static String passward;
    private static String driver;
    public String getJDBCUtils() {
        return "url:"+this.url+"  user:"+this.user+"  passward:"+this.passward+"  driver:"+this.driver;
    }
    /**
     * 文件的读取，只需要读取一次即可拿到这些值.使用静态代码块
     */
    static {
        //读取资源文件,获取值。
        try {
            //1.创建Properties集合类.
            Properties pro = new Properties();
            //2.加载文件linux服务器:/usr/**********/WEB-INF/prop/jdbc.properties
            pro.load(new FileReader("E:\\IDEA\\IdeaProjects\\jdbc\\jdbc\\src\\cn\\jdbc.properties"));
            //3.获取数据,赋值
            url = pro.getProperty("url");
            user = pro.getProperty("user");
            passward = pro.getProperty("password");
            driver = pro.getProperty("DriverClasses");
            //4.注册驱动
            Class.forName(driver);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    /**
     * 获取连接
     * @return 连接对象
     */
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url,user,passward);
    }
    /**
     * 释放资源
     * @param stmt
     * @param conn
     */
    public static void close(Statement stmt, Connection conn) {
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    /**
     * 释放资源
     * @param stmt
     * @param conn
     */
    public static void close(ResultSet rs, Statement stmt, Connection conn) {
        if (stmt != null) {
            try {
                stmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    public static void close(PreparedStatement pstmt, Connection conn) {
        if (pstmt != null) {
            try {
                pstmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

 

  • 数据库帮助类<通用方法执行存储过程>
package com.api.login.web;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.lang.reflect.InvocationTargetException;
import java.sql.*;
import java.util.*;

import org.apache.commons.beanutils.BeanUtils;


import java.beans.PropertyDescriptor;

public class DBHelper  {

    /**
     *  执行存储过程返回JSONObject 第一行数据 
     * @param var1 执行存储过程
     * @param var2 执行存储过程参数
     * @return  JSONArray
     * @throws SQLException
     */
    public JSONObject CallPro(String var1, List<Object> var2) throws SQLException {
        Connection var3 = JDBCUtils.getConnection();
        CallableStatement var4 = var3.prepareCall(var1);
        JSONObject var5 = new JSONObject();
        for (int i = 1; i < var2.size()+1; i++) {
            var4.setString(i, (String) var2.get(i-1));//参数的输入值
        }
        ResultSet var6 = var4.executeQuery();
        ResultSetMetaData var8 = var6.getMetaData(); //获取列集
        if (var6.next()) {//获取一行数据
            for (int i = 0; i < var8.getColumnCount(); i++) { //循环列
                String var7 = var8.getColumnName(i+1);//通过序号获取列名,起始值为1
                //rs.getString(rsMetaData.getColumnName(i+1));//通过列名获取值.如果列值为空,columnValue为null,不是字符型
                var5.put(var7, var6.getString(var7));
            }
        }
        JDBCUtils.close(var6,var4,var3);
        return var5;
    }

    /**
     *  执行存储过程返回泛型List，需要创建var3实体类
     * @param var1  执行sql
     * @param var2  执行sql参数
     * @param var3  泛型对象类型
     * @param <T>   泛型List
     * @return
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws IntrospectionException
     * @throws InvocationTargetException
     */
    public <T> List<T> CallPro1(String var1, List<Object> var2, Class var3) throws SQLException, InstantiationException, IllegalAccessException, IntrospectionException, InvocationTargetException {
        Connection var4 = JDBCUtils.getConnection();
        CallableStatement var5 = var4.prepareCall(var1);
        List<T> var6 = new ArrayList<>();
        for (int i = 1; i < var2.size()+1; i++) {
            var5.setString(i, (String) var2.get(i-1));//参数的输入值
        }
        ResultSet var7 = var5.executeQuery();
        while (var7.next()) {
            T var8 = (T) var3.newInstance();
                for (PropertyDescriptor var9 : Introspector.getBeanInfo(var3).getPropertyDescriptors()) {
                    if(!var9.getName().equals("class")) {
                        BeanUtils.copyProperty(var8, var9.getName(), var7.getString(var9.getName()));
                    }
                }
            var6.add(var8);
        }
        JDBCUtils.close(var7,var5,var4);
        return var6;
    }

    /**
     *  执行存储过程返回JSONArray，不需要创建实体类
     * @param var1 执行存储过程
     * @param var2 执行存储过程参数
     * @return  JSONArray
     * @throws SQLException
     */
    public JSONArray CallPro1(String var1, List<Object> var2) throws SQLException {
        Connection var3 = JDBCUtils.getConnection();
        CallableStatement var4 = var3.prepareCall(var1);
        JSONArray var5 = new JSONArray();
        for (int i = 1; i < var2.size()+1; i++) {
            var4.setString(i, (String) var2.get(i-1));//参数的输入值
        }
        ResultSet var6 = var4.executeQuery();
        ResultSetMetaData var8 = var6.getMetaData(); //获取列集
        while (var6.next()) {
            JSONObject var9 = new JSONObject();
            for (int i = 0; i < var8.getColumnCount(); i++) { //循环列
                String var7 = var8.getColumnName(i+1);//通过序号获取列名,起始值为1
                //rs.getString(rsMetaData.getColumnName(i+1));//通过列名获取值.如果列值为空,columnValue为null,不是字符型
                var9.put(var7, var6.getString(var7));
            }
            var5.add(var9);
        }
        JDBCUtils.close(var6,var4,var3);
        return var5;
    }

    /**
     * 执行存储过程，返回多个结果集 需要创建多个实体类，根据可选参数入参，需要和存储过程中的查询顺序对应
     * @param var1  执行存储过程
     * @param var2  执行存储过程参数
     * @param var3  多泛型对象类型
     * @param <T>   返回泛型
     * @return  ArrayList<List<T>>
     * @throws SQLException
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws IntrospectionException
     * @throws InvocationTargetException
     */
    public <T>  ArrayList<List<T>> CallPro2(String var1, List<Object> var2 , Class ...var3) throws SQLException, InstantiationException, IllegalAccessException, IntrospectionException, InvocationTargetException {
        Connection var4 = null;
        CallableStatement var5 = null;
        ResultSet var6 = null;
        List<T> var11 = new ArrayList<>();
        ArrayList<List<T>> var9 = new ArrayList<>();
        var4 = JDBCUtils.getConnection();
        var5 = var4.prepareCall(var1);
        for (int i = 1; i < var2.size()+1; i++) {
            var5.setString(i, (String) var2.get(i-1));//参数的输入值
        }
        int i = 1;
        var6=var5.executeQuery();
        while (var6.next()) {
            //类型的声明(可声明一个不确定的类型)
            T var7 = (T) var3[i-1].newInstance();
            for (PropertyDescriptor var8 : Introspector.getBeanInfo(var7.getClass()).getPropertyDescriptors()) {
                if(!var8.getName().equals("class")) {
                    //writeLog("获取第" + i + "个结果集" + "var8.getName():" + var8.getName());
                    BeanUtils.copyProperty(var7, var8.getName(), var6.getString(var8.getName()));
                }
            }
            var11.add(var7);
        }
        var9.add(var11);
        while (var5.getMoreResults()){
            i++;
            var6 = var5.getResultSet();
            var11 = new ArrayList<>();
            while (var6.next()){
                T var10 = (T) var3[i-1].newInstance();
                for (PropertyDescriptor var8 : Introspector.getBeanInfo(var10.getClass()).getPropertyDescriptors()) {
                    if(!var8.getName().equals("class")) {
                        //writeLog("获取第" + i + "个结果集" + "var8.getName():" + var8.getName());
                        BeanUtils.copyProperty(var10, var8.getName(), var6.getString(var8.getName()));
                    }
                }
                var11.add(var10);
            }
            var9.add(var11);
        }
        JDBCUtils.close(var6,var5,var4);
        return var9;
    }

    /**
     * 执行存储过程，返回多个结果集 
     * @param var1  执行存储过程
     * @param var2  执行存储过程参数
     * @return  多个结果集 JSONObject key为表名称 value为表数据
     * @throws SQLException
     */
    public JSONObject CallPro2(String var1, List<Object> var2) throws SQLException {
        Connection var3 = null ;
        CallableStatement var4 = null;
        //PreparedStatement var4 = null;
        ResultSetMetaData var5 = null;
        ResultSet var6 = null;
        JSONObject var7 = null;
        JSONArray var8 = null;

        JSONObject var9 = new JSONObject();
        var3 = JDBCUtils.getConnection();
        //var4 = var3.prepareCall(var1);
        var4 = var3.prepareCall(var1);
        for (int i = 1; i < var2.size()+1; i++) {
            var4.setString(i, (String) var2.get(i-1));//参数的输入值
        }
        var6=var4.executeQuery();
        var5 = var6.getMetaData(); //获取列集
        var8 = new JSONArray();
        while (var6.next()) {
            var7 = new JSONObject();
            for (int i = 0; i < var5.getColumnCount(); i++) { //循环列
                String columnName = var5.getColumnName(i+1);//通过序号获取列名,起始值为1
                //writeLog("rs.getString():"+rs.getString(resultSetMetaData.getColumnName(i+1)));//通过列名获取值.如果列值为空,columnValue为null,不是字符型
                var7.put(columnName, var6.getString(columnName));
            }
            var8.add(var7);
        }
        var9.put("table"+1,var8);
        int j = 1;
        while (var4.getMoreResults()){
            j++;
            var8 = new JSONArray();
            var6 = var4.getResultSet();
            var5 = var6.getMetaData(); //获取列集
            while (var6.next()){
                var7 = new JSONObject();
                for (int i = 0; i < var5.getColumnCount(); i++) { //循环列
                    String columnName = var5.getColumnName(i+1);//通过序号获取列名,起始值为1
                    //writeLog("rs.getString():"+var6.getString(var5.getColumnName(i+1)));//通过列名获取值.如果列值为空,columnValue为null,不是字符型
                    var7.put(columnName, var6.getString(columnName));
                }
                var8.add(var7);
            }
            var9.put("table"+j,var8);
        }
        JDBCUtils.close(var6,var4,var3);
        return var9;
    }

    public JSONArray CallPro3(String var1, List<Object> var2) throws SQLException {
        Connection conn= JDBCUtils.getConnection();
        PreparedStatement pstmt = conn.prepareStatement(var1);
        for (int i = 1; i < var2.size()+1; i++) {
            pstmt.setString(i, (String) var2.get(i-1));//参数的输入值
        }
        ResultSet rs = pstmt.executeQuery();
        ResultSetMetaData var5 = pstmt.getMetaData(); //获取列集
        JSONArray jsonArray = new JSONArray();
        while (rs.next()) {
            JSONObject jsonObject = new JSONObject();
            for (int i = 0; i < var5.getColumnCount(); i++) { //循环列
                String columnName = var5.getColumnName(i+1);//通过序号获取列名,起始值为1
                //writeLog("rs.getString():"+var6.getString(var5.getColumnName(i+1)));//通过列名获取值.如果列值为空,columnValue为null,不是字符型
                jsonObject.put(columnName, rs.getString(columnName));
            }
            jsonArray.add(jsonObject);
        }
        return jsonArray;
    }
}
  • 测试调用 
    @POST
    @Path("/getPro2")
    @Produces(MediaType.APPLICATION_JSON)
    public JSONObject getPro() throws SQLException, IntrospectionException, InvocationTargetException, InstantiationException, IllegalAccessException {
        String var1 = "{ call pro_Test(?,?,?) }";
        List<Object> list = new ArrayList<>();
        list.add("2");
        list.add("");
        list.add("");
        DBHelper dbHelper = new DBHelper();
        JSONObject jsonObject = dbHelper.CallPro(var1,list);
        return jsonObject;
    }

    @POST
    @Path("/getPro1")
    @Produces(MediaType.APPLICATION_JSON)
    public JSONArray getPro1() throws SQLException, IntrospectionException, InvocationTargetException, InstantiationException, IllegalAccessException {
        String var1 = "{ call pro_Test(?,?,?) }";
        List<Object> list = new ArrayList<>();
        list.add("2");
        list.add("");
        list.add("");
        DBHelper dbHelper = new DBHelper();
        List<UserInfos> userInfosList = dbHelper.CallPro1(var1,list,UserInfos.class);
        for (int i = 0; i < userInfosList.size(); i++) {
         writeLog("userInfosList.size():"+userInfosList.get(i).toString());
        }
        return JSONArray.parseArray(JSON.toJSONString(userInfosList));
    }

    @POST
    @Path("/getPro2")
    @Produces(MediaType.APPLICATION_JSON)
    public JSONArray getPro2() throws SQLException, IntrospectionException, InvocationTargetException, InstantiationException, IllegalAccessException {
        String var1 = "{ call pro_Test(?,?,?) }";
        List<Object> list = new ArrayList<>();
        list.add("2");
        list.add("");
        list.add("");
        DBHelper dbHelper = new DBHelper();
        JSONArray jsonArray = dbHelper.CallPro1(var1,list);
        return jsonArray;
    }

    @POST
    @Path("/getPro3")
    @Produces(MediaType.APPLICATION_JSON)
    public JSONObject getPro3() throws SQLException, IntrospectionException, InvocationTargetException, InstantiationException, IllegalAccessException {
        writeLog(">>>>>>>>>>>>>>.");
        String var1 = "{ call pro_Test2(?,?) }";
        List<Object> list = new ArrayList<>();
        list.add("3");
        list.add("2");
        DBHelper dbHelper = new DBHelper();
        ArrayList<List<Object>> userInfosList = dbHelper.CallPro2(var1,list,UserInfos.class,UserInfos2.class);
        JSONObject jsonObject = new JSONObject();
        for (int i = 0; i < userInfosList.size(); i++) {

            for (int j = 0; j <userInfosList.get(i).size() ; j++) {
                writeLog("userInfosList.get(i).size():"+userInfosList.get(i).get(j).toString());
            }
            writeLog(JSON.toJSONString(userInfosList.get(i)));
            jsonObject.put("table"+i+1,JSON.toJSONString(userInfosList.get(i)));
        }
        return jsonObject;
    }

    @POST
    @Path("/getPro4")
    @Produces(MediaType.APPLICATION_JSON)
    public JSONObject getPro4() throws SQLException {
        writeLog(">>>>>>>>>>>>>>.");
        String var1 = "{ call pro_Test2(?,?) }";
        List<Object> list = new ArrayList<>();
        list.add("3");
        list.add("2");

        for (int i = 0; i < list.size(); i++) {
            writeLog(">>>>>>>>>"+i+">>>>>>>>>:"+list.get(i).toString());
        }

        DBHelper dbHelper = new DBHelper();
        JSONObject userInfosList = dbHelper.CallPro2(var1,list);
        writeLog("jsonObject:  "+userInfosList.toJSONString());
        return userInfosList;
    }

    @POST
    @Path("/getCommonDataTablePro")
    @Produces(MediaType.APPLICATION_JSON)
    public JSONObject getCommonDataTablePro(@Context HttpServletRequest request) throws SQLException {
        DBHelper var1 = new DBHelper();//数据库执行帮助类
        JSONObject var2 = new JSONObject();//执行查询1返回的JSONObject
        List<Object> var3 = new ArrayList();//执行查询1的入参
        String var4 = "select * from uf_jcpro where id = ? ";//执行存储过程查询1
        JSONObject var5 = new JSONObject();//整个方法返回的JSONObject
        String var6 = "";//执行存储过程查询1
        List<Object> var7 = new ArrayList();//执行查询2的入参
        var3.add(Util.null2String(request.getParameter("proId")));
        var2 = var1.GetModel(var4,var3);
        var6 =  "{ call "+var2.get("proName")+"(";
        String [] var8 = Util.null2String(request.getParameter("var2")).split(",");
        for (String s : var8) {
            var7.add(s);
            var6 += "?,";
        }
        var6 = var6.substring(0, var6.lastIndexOf(","));
        var6+=") }";
        var5 = var1.CallPro2(var6,var7);
        DocDownloadCheckUtil.getDownloadfileidstr("");



        return var5;
    }

存储过程1

 create PROCEDURE [dbo].[pro_updateHrmResourceByUserId] 
    	@UID VARCHAR(50),
    	@mobile VARCHAR(50),
    	@email VARCHAR(50),
    	@regresidentplace VARCHAR(50),
    	@residentplace VARCHAR(50),
    	@policy VARCHAR(50),
    	@educationlevel VARCHAR(50),
    	@field14 VARCHAR(50),
    	@field15 VARCHAR(50),
		@certificatenum VARCHAR(50)
as
begin
 set nocount on

	declare  @statement_list INT;

	--update   hrmresource
	--set email='156@qq.com'
	--where mobile=1356878928

	select
		mobile,
		email,
		regresidentplace,
		residentplace,
		policy,
		educationlevel
	from hrmresource where id=7

set nocount off
end
  • 存储过程2 
     create procedure [dbo].[pro_Test2]
 @id1 NVARCHAR(50),
 @id2 NVARCHAR(50)
 as
 begin
 set nocount on
 
 --exec [pro_Test] @id1,'',''
 insert into  mytest_log (time,proName,var1,var2) values (GETDATE(),'[pro_Test2]',@id1,@id2)

 select id ,name ,age from mytest where id > @id1
  
 select id ,name  from mytest where id > @id2
 
 
 set nocount off
 end
 
 --select*from mytest_log where var1='1'
 
--exec [pro_Test2] '2','3'
 
-- truncate table mytest_log
  • 存储过程3 
 create procedure [dbo].[pro_Test]
 @id NVARCHAR(50),
 @name NVARCHAR(50),
 @age NVARCHAR(50)
 as
 begin
 set nocount on
 
 INSERT INTO mytest_log (time,proName,var1,var2,var3) values (GETDATE(),'[pro_Test]',@id,@name,@age)
 
 select * from mytest where id > @id
  set nocount off
 end
 
 --select * from uf_jcpro where id = 2
  • 存储过程4  
    create procedure [dbo].[pro_Test3]
 @id NVARCHAR(50),
 @name NVARCHAR(50),
 @age NVARCHAR(50)
 as
 begin
 
 INSERT INTO mytest_log (time,proName) values (GETDATE(),'[pro_Test3]')

  select * from mytest where name = @name
  
 end

注意：存储过程中如果存在 插入、修改和删除会执行失败 

        需要在begin和end间加入  set nocount on和 set nocount off，忽略受影响行数

只会hello word！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
执行与修改存储过程
geyulei的博客
06-22 1万+
1.执行存储过程  要运行某个存储过程，只要简单地通过名字就可以引用它。如果对存储过程的调用不是批处理中的第一条语句，则需要使用EXECUTE关键字。下面是执行存储过程的语法格式。[[EXEC[UTE]]]   {[@return_status=]   procedure_name[;number]|@procedure_name_var}[[@parameter=]{value|@variabl...
存储过程详解
weixin_34082177的博客
01-02 2551
存储过程简介 什么是存储过程：存储过程可以说是一个记录集吧，它是由一些T-SQL语句组成的代码块，这些T-SQL语句代码像一个方法一样实现一些功能（对单表或多表的增删改查），然后再给这个代码块取一个名字，在用到这个功能的时候调用他就行了。存储过程的好处：1.由于数据库执行动作时，是先编译后执行的。然而存储过程是一个编译过的代码块，所以执行效率要比T-SQL语句高。2.一个存储过程在程序在网络...
查看存储过程执行情况
01-14
2、登陆数据库，执行如下语句，查看当前进行io操作的进程和模块名称： SELECT se.sid,se.serial#,pr.SPID,se.username,se.status,se.terminal,se.program, se.MODULE,se.sql_address,st.event,st.p1text,si.physical_reads,si.block_changes FROM v$session se,v$session_wait st,v$sess_io si,v$process pr WHERE st.sid=se.sid AND st.sid=si.sid AND se.PADDR=pr.ADDR and se.username is not null AND se.sid>6 AND st.wait_time=0 AND st.event NOT LIKE '%SQL%' ORDER BY physical_reads DESC
数据库原理_ 存储过程与触发器
qq_45915957的博客
05-28 5625
七、存储过程与触发器 1、要求 1、执行存储过程时，实参数等于存储过程中形参数；实参数少于存储过程中形参数； 2、执行存储过程；通过对表操作触发激发触发器执行并查看结果。 实验环境：MySQL 实验步骤 1． 定义存储过程 ① 创建一个能向学生表Student中插入一条记录的存储过程Insert_student，该存储过程需要五个参数，分别用来传递学号、姓名、班级号、性别、出生日期5个值。 插入一条记录的存储过程Insert_student: ②执行存储过程Insert_student，向Student表中
如何执行存储过程
xieyangxixia的博客
02-19 135
提问和评论都可以，用心的回复会被更多人看到。
存储过程的执行
weixin_30642869的博客
02-21 120
,sp_executesql 的参数必须为UNICODE,即NCHAR,NVARCHAR,NTEXT型,否则报错 动态sql语句基本语法1 :普通SQL语句可以用Exec执行Select * from tableNameExec('select * from tableName')Exec sp_executesql N'select * from tableNam...
存储过程浅入深出
qq_54054566的博客
08-29 1708
1、一种为了完成特定功能的一个或一组SQL语句集合。经编译后存储在服务器端的数据库中，可以利用存储过程来加速SQL语句的执行。2、调用名称，传入参数，执行来完成特定功能。执行：execute / exec 存储过程名 参数列表（多个参数，以逗号隔开）优点：1.提高应用程序的通用性和可移植性。多次调用，而不必重新再去编写，维护人员可以随时修改。2.可以更有效的管理数据库权限。3.提高执行SQL的速度。4.减轻服务器的负担。缺点：专门维护它，占用数据库空间。........................
ASP.NET通过存储过程操作数据库
lytton_jing
04-27 1331
在实际编程中，一些代码段是可以重复使用的，为了增强代码的重用性，可以在数据库中（例如：SQL Server数据库、Oracle数据库等）创建存储过程 在实际编程中，一些代码段是可以重复使用的，为了增强代码的重用性，可以在数据库中（例如：SQL Server数据库、Oracle数据库等）创建存储过程，然后在ASP.NET程序中调用该存储过程即可。存储过程中的内容是经编译后存储
oracle存储过程
qq_37846169的博客
06-06 2110
存储过程是被命名的 PL/SQL 块，存储于数据库中，是数据库对象的一种。应用程序可以调用存储过程，执行相应的逻辑。
6.4 存储过程的使用
蟑螂恶霸的博客
03-05 525
目前为止，我们使用的大多数 SQL 语句都是针对一个或多个表的单条语句。确认订单时，必须保证库存中有相应的物品；如果物品有库存，需要预定，不再出售给别的人，并且减少物品数据以反映正确的库存量；如果库存中没有的物品需要订购，这需要与供应商进行某种交互；关于哪些物品入库（并且可以立即发货）和哪些物品退订，需要通知相应的顾客；这显然不是一个完整的例子，它甚至超出了样例表的范围，但足以表达我们的意思了。执行这个处理需要针对许多表的多条 SQL 语句。
C# winform调用SQL存储过程-菜鸟入门 详细注释
08-05
内容概要：简单的C# winform调用存储过程实例，创建存储过程入参，通过SqlConnection对象和SqlCommand对象调用存储过程，获取存储过程的出参并显示出来，详细代码注释，希望对用到C#调用存储过程的小伙伴有帮助 ...
C#调用存储过程的通用类
05-24
C#调用存储过程的通用类,文档中包含调用存储过程的源代码
针对存储过程通用的jdbc封装
05-18
针对java调用存储过程写的通用封装,oracle,mssql测试通过,附带测试脚本.以前写过一个,感觉不是很好,这个周末就重写了一个,大家多多提意见,是eclipse工程直接跑junit就行了,所有的东西都在里面.除了存储过程也可以...
springboot mybatis 动态调用oracle存储过程，通过存储过程名称，就能动态调用存储过程、java动态调用or
05-23
能不能写个动态的业务，只输入存储过程名称，自动获取存储过程参数，并且参数的数据从前台传递过来，这个就通用了。只写一个通用方法，就可以调用所有的存储过程。只根据输入不同的存储过程名称、参数内容，自动调用...
GBase 8S 自定义存储过程和函数.doc
09-23
存储过程类似于高级语言中的函数，可被用户的应用程序调用，执行。不同的是，存储过程经过编译后存放在服务器端，这为开发C/S和B/S应用程序提供了强有力的支持。由于存储过程是已经编译好的代码，所以执行时不必再次...
Day25-Java基础之常用类1
m0_46053885的博客
04-27 1105
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
链表刷题集
最新发布
yajunjiao的专栏
04-30 475
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1068
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
godror 执行存储过程通用方法
02-16
Godror 是一个针对 Go 语言的 Oracle 数据库驱动程序，提供了多种方式执行存储过程。以下是其中一种通用方法： 1. 创建存储过程 ```sql CREATE OR REPLACE PROCEDURE example_proc ( p_input IN VARCHAR2, p_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值