csharp: Oracle Stored Procedure DAL using ODP.NET

paging : http://www.codeproject.com/Articles/44858/Custom-Paging-GridView-in-ASP-NET-Oracle

Oracle sql:

--书分类目录kind
-- Geovin Du
create table BookKindList
(
	BookKindID INT   PRIMARY KEY,
	BookKindName nvarchar2(500) not null,
	BookKindParent INT  null,
	BookKindCode varchar(100)   ---編號
);
--序列创建

drop SEQUENCE BookKindList_SEQ;

CREATE SEQUENCE BookKindList_SEQ
INCREMENT BY 1     -- 每次加几个
START WITH 1     -- 从1开始计数
NOMAXVALUE        -- 不设置最大值
NOCYCLE            -- 一直累加，不循环
NOCACHE;           --设置缓存cache个序列，如果系统down掉了或者其它情况将会导致序列不连续，也可以设置为---------NOCACHE

--自增长触发器
drop trigger BookKindList_ID_AUTO;

 create or replace trigger BookKindList_ID_AUTO
  before insert on BookKindList   --BookKindList 是表名
  for each row
declare
  nextid number;
begin
  IF :new.BookKindID IS NULL or :new.BookKindID=0 THEN --BookKindID是列名
    select BookKindList_SEQ.Nextval --BookKindList_SEQ正是刚才创建的
    into nextid
    from dual;
    :new.BookKindID:=nextid;
  end if;
end;    

-- 添加
drop PROCEDURE proc_Insert_BookKindList;

CREATE OR REPLACE PROCEDURE proc_Insert_BookKindList
(
temTypeName nvarchar2,
temParent number
)
AS
ncount number;
begin
--SELECT COUNT (*) INTO ncount FROM BookKindList fm1 where  EXISTS (SELECT BookKindName from BookKindList fm2 where  fm2.BookKindName=temTypeName);--判斷是否存
SELECT count(*) INTO ncount FROM BookKindList where BookKindName=temTypeName;
if ncount<=0 then
begin
INSERT INTO BookKindList (BookKindName,BookKindParent) VALUES(temTypeName,temParent);
commit;
end;
else
begin
  SELECT BookKindID INTO ncount FROM BookKindList where BookKindName=temTypeName;
  dbms_output.put_line(‘存在相同的记录,添加不成功!‘||ncount);
end;
end if;
Exception
    When others then
      dbms_output.put_line(‘存在问题,添加不成功!‘||ncount);
       Rollback;
end proc_Insert_BookKindList;

--测试 oracle 11g 涂聚文 20150526
exec proc_Insert_BookKindList (‘油彩画‘,3);

drop PROCEDURE proc_Insert_BookKindOut;

drop PROCEDURE procInsertBookKindOut;
 -- 添加有返回值
CREATE OR REPLACE PROCEDURE proc_Insert_BookKindOut --添加返回ID
(
temTypeName nvarchar2,
temParent int,
temId out int
)
AS
ncount number;
reid number;
begin
--SELECT COUNT (*) INTO ncount FROM BookKindList fm1 where  EXISTS (SELECT BookKindName from BookKindList fm2 where  fm2.BookKindName=temTypeName);--判斷是否存
SELECT count(*) INTO ncount FROM BookKindList where BookKindName=temTypeName;
if ncount<=0 then
begin
--INSERT INTO BookKindList (BookKindID,BookKindName,BookKindParent) VALUES(BookKindList_SEQ.nextval,temTypeName,temParent);
INSERT INTO BookKindList (BookKindName,BookKindParent) VALUES(temTypeName,temParent);
select BookKindList_SEQ.currval into reid from dual;
temId:=reid;
dbms_output.put_line(‘添加成功!‘||temId);
commit;
end;
else
begin
  SELECT BookKindID INTO ncount FROM BookKindList where BookKindName=temTypeName;
  dbms_output.put_line(‘存在相同的记录,添加不成功!‘||ncount);
  temId:=0;
end;
end if;
Exception
    When others then
    begin
      dbms_output.put_line(‘存在问题,添加不成功!‘||ncount);
      temId:=0;
       Rollback;
    end;
end proc_Insert_BookKindOut;

--测试 oracle 11g 涂聚文 20150526
declare
mid  number:=0;
nam  nvarchar2(100):=‘黑白画‘;
par  number:=3;
begin
--proc_Insert_BookKindOut(nam in nvarchar2,par in int,mid in out int);
proc_Insert_BookKindOut(nam,par ,mid);
if mid>0 then
dbms_output.put_line(‘添加成功!输出参数:‘||mid);
else
dbms_output.put_line(‘存在相同的记录,添加不成功!输出参数:‘||mid);
end if;
end;

--修改
CREATE OR REPLACE PROCEDURE procUpdateBookKindList (
p_id IN INT,--BookKindList.BookKindID%TYPE,
p_name IN nvarchar2,--BookKindList.BookKindName%TYPE,
p_parent IN INT,--BookKindList.BookKindParent%TYPE,
p_code IN varchar--BookKindList.BookKindCode%TYPE
)
IS
ncount number;
BEGIN
SELECT count(*) INTO ncount FROM BookKindList where BookKindName=p_name;
if ncount<=0 then
begin
UPDATE BookKindList SET BookKindName=p_name,BookKindParent=p_parent,BookKindCode=p_code WHERE BookKindID=p_id;
COMMIT;
end;
else
begin
  SELECT BookKindID INTO ncount FROM BookKindList where BookKindName=p_name;
  dbms_output.put_line(‘存在相同的记录,修改不成功!‘||ncount);
end;
end if;
END procUpdateBookKindList;  

--测试
begin
procUpdateBookKindList(8,‘哲学‘,1,‘Geovin Du‘);
end;

--删除
CREATE OR REPLACE PROCEDURE procDeleteBookKindList(p_BookKindID IN BookKindList.BookKindID%TYPE)
IS
BEGIN

  DELETE BookKindList where BookKindID = p_BookKindID;
  COMMIT;
END;

---一条记录
--创建包:
create or replace package pack_BookKindId is
       type cur_BookKindId is ref cursor;
end pack_BookKindId; 

--创建存储过程
create or replace procedure procSelectBookKindList
(p_id in int,p_cur out pack_BookKindId.cur_BookKindId)
is
       v_sql varchar2(400);
begin  

       if p_id = 0 then   --0 查询所有
          open p_cur for select * from BookKindList;
       else
          v_sql := ‘select * from BookKindList where BookKindID =: p_id‘;
          open p_cur for v_sql using p_id;
       end if;
end procSelectBookKindList;

--创建包以游标的形式返回BookKindList表的所有记录结果集

drop package pkg_Select_BookKindListAll;

drop procedure proc_Select_BookKindListAll;

create or replace package pkgSelectBookKindListAll is
-- Author  : geovindu
  type mycur is ref cursor;
  procedure procSelectBookKindListAll(cur_return out mycur);
end pkgSelectBookKindListAll;

create or replace package body pkgSelectBookKindListAll is
  -- Function and procedure implementations
 procedure procSelectBookKindListAll(cur_return out mycur)
  is
  begin
   open cur_return for select * from BookKindList;

  end procSelectBookKindListAll;

end pkgSelectBookKindListAll;

-- 测试包和存储过程查询表中所有内容
declare
--定义游标类型的变量
cur_return pkgSelectBookKindListAll.mycur;
--定义行类型
pdtrow BookKindList%rowtype;
begin
  --执行存储过程
  pkgSelectBookKindListAll.procSelectBookKindListAll(cur_return);
  --遍历游标中的数据
       LOOP
         --取当前行数据存入pdtrow
           FETCH cur_return INTO pdtrow;
           --如果未获取数据就结束循环
           EXIT WHEN cur_return%NOTFOUND;
           --输出获取到的数据
           DBMS_OUTPUT.PUT_LINE (pdtrow.BookKindID||‘，‘||pdtrow.BookKindName);
         END LOOP;
         CLOSE cur_return;
end;

　　csharp code:

/// <summary>
    /// 20160918 涂聚文
    /// Geovin Du
    /// </summary>
    public class BookKindListDAL : IBookKindList
    {
        //private static string connectionString [email protected]"DATA SOURCE=oracle11g;USER ID=geovin;password=geovindu;";
        ///<summary>
        /// 追加记录
        ///</summary>
        ///<param name="BookKindListInfo"></param>
        ///<returns></returns>
        public int InsertBookKindList(BookKindListInfo bookKindList)
        {
            int ret = 0;
            try
            {
                OracleParameter[] par = new OracleParameter[]{
				new OracleParameter("temTypeName",OracleDbType.NVarchar2,1000),
				new OracleParameter("temParent",OracleDbType.Int32,4),
				};
                par[0].Value = bookKindList.BookKindName;
                par[0].Direction = ParameterDirection.Input;
                par[1].Value = bookKindList.BookKindParent;
                par[1].Direction = ParameterDirection.Input;
                ret = OracleHelper.ExecuteSql("proc_Insert_BookKindList", CommandType.StoredProcedure, par);
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return ret;
        }
        /// <summary>
        /// 追加记录返回
        /// </summary>
        /// <param name="authorList"></param>
        /// <param name="authorID"></param>
        /// <returns></returns>
        public int InsertBookKindOutput(BookKindListInfo bookKindList, out int bookKindLID)
        {
            bookKindLID = 0;
            int ret = 0;
            try
            {
                OracleParameter[] par = new OracleParameter[]{
				new OracleParameter("temTypeName",OracleDbType.NVarchar2,1000),
                new OracleParameter("temParent",OracleDbType.Int32,4),
                new OracleParameter("temId",OracleDbType.Int32,4),
				};
                par[0].Value = bookKindList.BookKindName;
                par[0].Direction = ParameterDirection.Input;
                par[1].Value = bookKindList.BookKindParent;
                par[1].Direction = ParameterDirection.Input;
                par[2].Direction = ParameterDirection.Output;
                ret = OracleHelper.ExecuteSql("proc_Insert_BookKindOut", CommandType.StoredProcedure, par);
                if (ret > 0)
                {
                    bookKindLID =int.Parse(par[2].Value.ToString());
                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return ret;
        }
        ///<summary>
        ///修改记录
        ///涂聚文 20160920
        ///</summary>
        ///<param name="BookKindListInfo"></param>
        ///<returns></returns>
        public int UpdateBookKindList(BookKindListInfo bookKindList)
        {
            int ret = 0;
            try
            {
                OracleParameter[] par = new OracleParameter[]{
				new OracleParameter("p_id",OracleDbType.Int32,4),
				new OracleParameter("p_name",OracleDbType.NVarchar2,1000),
				new OracleParameter("p_parent",OracleDbType.Int32,4),
                new OracleParameter("p_code",OracleDbType.Varchar2,1000),
				};
                par[0].Value = bookKindList.BookKindID;
                par[0].Direction = ParameterDirection.Input;
                par[1].Value = bookKindList.BookKindName;
                par[1].Direction = ParameterDirection.Input;
                par[2].Value = bookKindList.BookKindParent;
                par[2].Direction = ParameterDirection.Input;
                par[3].Value = bookKindList.BookKindCode;
                par[3].Direction = ParameterDirection.Input;
                ret = OracleHelper.ExecuteSql("procUpdateBookKindList", CommandType.StoredProcedure, par);
               // ret = 1;
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return ret;
        }
        ///<summary>
        /// 删除记录
        ///</summary>
        ///<param name="bookKindIDInfo"></param>
        ///<returns></returns>
        public bool DeleteBookKindList(int bookKindID)
        {
            bool ret = false;
            try
            {
                OracleParameter par = new OracleParameter("p_BookKindID", bookKindID);
                par.Direction = ParameterDirection.Input;
                int temp = 0;
                temp = OracleHelper.ExecuteSql("procDeleteBookKindList", CommandType.StoredProcedure, par);
                if (temp != 0)
                {
                    ret = true;
                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return ret;
        }
        ///<summary>
        /// 查询记录
        ///</summary>
        ///<param name="bookKindIDInfo"></param>
        ///<returns></returns>
        public BookKindListInfo SelectBookKindList(int bookKindID)
        {
            BookKindListInfo bookKindList = null;
            try
            {
                OracleParameter[] par = new OracleParameter[]{
                new OracleParameter("p_id",OracleDbType.Int32,4),
               new OracleParameter("p_cur",OracleDbType.RefCursor),
            };
                par[0].Value = bookKindID;
                par[0].Direction = ParameterDirection.Input;
                par[1].Direction = ParameterDirection.Output;
                using (OracleDataReader reader = OracleHelper.GetReader("procSelectBookKindList", CommandType.StoredProcedure, par)) //proc_Select_BookKindList 提示名称过长Oracle
                {
                    if (reader.Read())
                    {
                        bookKindList = new BookKindListInfo();
                        bookKindList.BookKindID = (!object.Equals(reader["BookKindID"], null)) ? (decimal)reader["BookKindID"] : 0;
                        bookKindList.BookKindName = (!object.Equals(reader["BookKindName"], null)) ? (string)reader["BookKindName"] : "";
                        bookKindList.BookKindParent = (!object.Equals(reader["BookKindParent"], null)) ? (decimal)reader["BookKindParent"] : 0;

                    }
                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return bookKindList;
        }

        ///<summary>
        /// 查询所有记录
        ///</summary>
        ///<returns></returns>
        public List<BookKindListInfo> SelectBookKindListAll()
        {
            List<BookKindListInfo> list = new List<BookKindListInfo>();
            BookKindListInfo bookKindList = null;
            try
            {
                //定义参数，注意参数名必须与存储过程定义时一致，且类型为OracleType.Cursor
                OracleParameter cur_set = new OracleParameter("cur_return", OracleDbType.RefCursor);
                //设置参数为输出类型
                cur_set.Direction = ParameterDirection.Output;
                //
                //OracleHelper.ExecuteReader(connectionString, CommandType.StoredProcedure, "pkg_Select_BookKindListAll.proc_Select_BookKindListAll", cur_set)
                using (OracleDataReader reader = OracleHelper.GetReader("pkg_Select_BookKindListAll.proc_Select_BookKindListAll", CommandType.StoredProcedure, cur_set))
                {
                    while (reader.Read())
                    {
                        bookKindList = new BookKindListInfo();
                        string s = reader["BookKindID"].ToString();
                        bookKindList.BookKindID = (!object.Equals(reader["BookKindID"], null)) ? (decimal)reader["BookKindID"] : 0;
                        bookKindList.BookKindName = (!object.Equals(reader["BookKindName"], null)) ? (string)reader["BookKindName"] : "";
                        bookKindList.BookKindParent = (!object.Equals(reader["BookKindParent"], null)) ? (decimal)reader["BookKindParent"] : 0;
                        list.Add(bookKindList);

                    }
                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return list;
        }
        ///<summary>
        /// 查询所有记录
        ///</summary>
        ///<returns></returns>
        public DataTable SelectBookKindListDataTableAll()
        {
            DataTable dt = new DataTable();
            try
            {
                //定义参数，注意参数名必须与存储过程定义时一致，且类型为OracleType.Cursor
                OracleParameter cur_set = new OracleParameter("cur_return", OracleDbType.RefCursor);
                //设置参数为输出类型
                cur_set.Direction = ParameterDirection.Output;
                //添加参数
                //comm.Parameters.Add(cur_set);
                using (DataTable reader = OracleHelper.GetTable("pkgSelectBookKindListAll.procSelectBookKindListAll", CommandType.StoredProcedure, cur_set))
                {
                    dt = reader;

                }
            }
            catch (OracleException ex)
            {
                throw ex;
            }
            return dt;
        }

        /// <summary>
        /// 填充dataSet数据集－Oracle库
        /// </summary>
        /// <param name="pindex">当前页</param>
        /// <param name="psql">执行查询的SQL语句</param>
        /// <param name="psize">每页显示的记录数</param>
        /// <returns></returns>
        private bool gridbind(int pindex, string psql, int psize)
        {
            OracleConnection conn = new OracleConnection();
            OracleCommand cmd = new OracleCommand();
            OracleDataAdapter dr = new OracleDataAdapter();
            conn.ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["ConnectionString"].ConnectionString;
            cmd.Connection = conn;
            cmd.CommandType = CommandType.StoredProcedure;
            conn.Open();
            cmd.CommandText = "DotNet.DotNetPageRecordsCount";
            cmd.Parameters.Add("psqlcount", OracleDbType.Varchar2).Value = psql;
            cmd.Parameters.Add("prcount", OracleDbType.Int32).Direction = ParameterDirection.Output;

            cmd.ExecuteNonQuery();
            string PCount = cmd.Parameters["prcount"].Value.ToString();
            cmd.Parameters.Clear();
            cmd.CommandText = "DotNet.DotNetPagination";
            if (pindex != 0)
            {
                cmd.Parameters.Add("pindex", OracleDbType.Int32).Value = pindex - 1;
            }
            else
            {
                cmd.Parameters.Add("pindex", OracleDbType.Int32).Value = pindex;
            }
            cmd.Parameters.Add("psql", OracleDbType.Varchar2).Value = psql;
            cmd.Parameters.Add("psize", OracleDbType.Int32).Value = psize;
            cmd.Parameters.Add("v_cur", OracleDbType.RefCursor).Direction = ParameterDirection.Output;
            cmd.Parameters.Add("pcount", OracleDbType.Int32).Direction = ParameterDirection.Output;
            dr.SelectCommand = cmd;
            try
            {
                DataSet ds = new DataSet();
                dr.Fill(ds);
                //显示页码条的状态
                //showStatus(Convert.ToInt32(cmd.Parameters["pindex"].Value + 1,
                //    Convert.ToInt32(cmd.Parameters["pcount"].Value),
                //    Convert.ToInt32(PCount));
                for (int i = 0; i < ds.Tables.Count; i++)
                { //把数据行为零的表删除
                    if (ds.Tables[i].Rows.Count == 0)
                        ds.Tables.Remove(ds.Tables[i].TableName);
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
                return false;
            }

            conn.Close();
            return true;
        }
    }

　　

时间： 2024-11-08 10:00:20

csharp: Oracle Stored Procedure DAL using ODP.NET的相关文章

Oracle Stored Procedure demo

1.how to find invalid status stored procedure and recompile them? SELECT OBJECT_NAME , status FROM user_objects WHERE OBJECT_TYPE = 'PROCEDURE'; Alter procedure schme.procedurename compile; 缺少练习的学习不是完整的学习,练习才是学习,总结才有思考.   SELECT OBJECT_NAME , STATUS

csharp: MySQL Stored Procedure using DAL

# 建表 塗聚文 20160907 drop table attendrecord; create table attendrecord ( seq INT NOT NULL PRIMARY KEY AUTO_INCREMENT, emp_no varchar(20) null, rdate datetime not null, rtime time not null, rdescription varchar(100), rdes_reasnon varchar(100), branch va

Oracle Java Stored Procedure + 包调用

1. 创建Java Stored Procedure create or replace and compile java source named "TestHello" as public class TestHello{   public static void test(){     System.out.println("Hello");   } } 2.创建JSP调用存过或方法(本例为在包创建的存过) create or replace package 

Oracle中的存储过程（Stored Procedure）

一.存储过程的定义 存储过程(Stored Procedure)是在大型数据库系统中,一组为了完成特定功能的SQL 语句集,存储在数据库中,经过第一次编译后再次调用不需要再次编译,用户通过指定存储过程的名字并给出参数(如果该存储过程带有参数)来执行它.存储过程是数据库中的一个重要对象. 二.基本语法 创建存储过程 create procedure sp_name @[参数名] [类型],@[参数名] [类型] as begin ......... end 以上格式还可以简写成: create p

【机房重构】——存储过程（Stored Procedure）

[前言] 在学习数据库知识时,就曾经接触过存储过程,当时只是如蜻蜓点水一般,短暂的停留,并没有留下什么印象,在进行机房重构学习过程中,又重新认识了存储结构,从开始的抵触,不想用到后来逐渐了解,学着使用,思路越来越清晰,真正去做了才发现了其中的乐趣:常常说学习需要多总结,现在就是在积累,每一次的收获都要整理记录,才能留下深刻的印象,下面就来学习一下存储过程的知识吧. [存储过程的概念] 在采用客户机/服务器(C/S)计算模式的数据库系统中,很多工作可以在客户端完成,也可以在服务器端完成,数据库除了

EntityFramework 学习 一 Stored Procedure

CREATE PROCEDURE [dbo].[GetCoursesByStudentId] -- Add the parameters for the stored procedure here @StudentId int = null AS BEGIN -- SET NOCOUNT ON added to prevent extra result sets from -- interfering with SELECT statements. SET NOCOUNT ON; -- Inse

Publishing Stored Procedure Execution in Transactional Replication

Replication 不仅可以将Table Article 或 SP Article 推送到subscription,而且还能将sp的execution推送到subscription.推送sp的execution是指将执行sp的command 推送到subscriber去执行, 而不是将sp执行之后产生的大量transaction推送到subscriber上.Transaction是逐个更新Table Article中的数据行. 推送sp的execution来同步subscription的数据

在JDBC中传递table参数给SQL server stored procedure

SQL Server JDBC驱动不支持直接传递Table参数给stored procedure 我的做法是先创建一个临时表,将需要插入的数据先插入到临时表里面,然后把这个临时表作为参数,传送给stored procedure.使用了Preparestatement来避免SQL注入问题. 先创建User Defined Table CREATE TYPE UserIdList AS TABLE( userId uniqueidentifier NOT NULL ); 再创建存储过程: CREAT

Stored Procedure 里的 WITH RECOMPILE 到底是干麻的？

原文:Stored Procedure 里的 WITH RECOMPILE 到底是干麻的? 在 SQL Server 创建或修改「存储过程(stored procedure)」时,可加上 WITH RECOMPILE 选项,但多数文档或书籍都写得语焉不详,或只解释为「每次执行此存储过程时,都要重新编译」.事实上,是指执行此一存储过程时,要强制重新产生「执行计划(execution plan)」,而不要从「缓存(cache)」去取得旧的「执行计划」. SQL Server 在评估与产生「执行计划」