精华内容
下载资源
问答
  • 2019-02-28 15:58:24

    一、【事务概念】

    事务(Transaction)是指构成单一逻辑工作单元的操作集合,要么完整地执行,要么完全不执行。

    1,如果事务中有的操作没有成功完成,则事务中的所有操作都需要被回滚,回到事务执行前的状态(要么全执行,要么全都不执行);

    2,同时,该事务对数据库或者其他事务的执行无影响,所有的事务都好像在独立的运行。

    二、【事务举例】

    用一个常用的“A 账户向 B 账户汇钱”的例子来说明如何通过数据库事务保证数据的准确性和完整性。熟悉关系型数据库事务的都知道从账户 A 到账户 B 需要 6 个操作,分别为:

    1.从 A 账户中把余额读出来(500)

    2. 对 A 账户做减法操作(500 - 100)

    3. 把结果写回 A 账户中(400)

    4. 从 B 账户中把余额读出来(500)

    5. 对 B 账户做加法操作(500 + 100)

    6. 把结果写回 B 账户中(600)

    三、【事务特性】

    并非任意的对数据库的操作序列都是数据库事务,事务应该具有 4 个属性,分别为:原子性、一致性、隔离性和持久性。这四个属性通常称为ACID特性。

    1.原子性(Atomicity):一个事务对数据库的所有操作,是一个不可分割的工作单元,这些操作要么全部被执行,要么都不执行;

    保证 1-6 所有过程要么都执行,要么都不执行。

    一旦在执行某一步骤的过程中发生问题,就需要执行回滚操作。

    假如执行到第 5 步的时候,B 账户突然不可用(比如被注销),那么之前的所有操作都应该回滚到执行事务之前的状态。

    2.一致性(Consistency):事务应确保数据库的状态从一个一致状态转为另一个一致状态,一致状态的含义是数据库中的数据应满足完整性约束;

    在转账之前,A 和 B 的账户中共有 500 + 500 = 1000 元钱。

    在转账之后,A 和 B 的账户中也应该共有 400 + 600 = 1000 元钱。

    也就是说,数据的状态在执行该事务操作之后从一个状态改变到了另外一个状态。同时一致性还能保证账户余额不会变成负数等。

    注:一致性与原子性是密切相关的,原子性的破坏可能导致数据库的不一致,数据的一致性问题并不都和原子性有关。

    比如上面的例子,在第5 步的时候,对 B 账户做加法时只加了 50 元。那么,该过程可以符合原子性,但是数据的一致性就出现了问题。因此,事务的原子性与一致性缺一不可。

    3.隔离性(Isolation):多个事务并发执行时,一个事务的执行不应影响其他事务的执行;

    在 A 向 B 转账的整个过程中,只要事务还没有提交(commit),查询 A 账户和 B 账户的时候,两个账户里面的钱的数量都不会有变化。

    如果在 A 给 B 转账的同时,有另外一个事务执行了 C 给 B 转账的操作,那么当两个事务都结束的时候,B 账户里面的钱应该是 A 转给 B 的钱加上 C 转给 B 的钱再加上自己原有的钱。

    4.持久性(Durability):一个事务一旦提交,它对数据库的修改应该永久保存在数据库中。

    例如我们在数据库,用update语句更新某条记录时,会默认开启一个数据库事务,当我们执行(F8)这条语句后,再次查询这条记录,已经被更新,但没有提交事务,事务并没有对数据库产生影响。此时如果关闭查询窗口(出现故障),并未对数据库记录产生影响,只有将事务提交之后,这条记录才会真正并永久的更新。

    四、【事务并发】

    事务并发:一个数据库可能拥有多个访问客户端,这些客户端都可以并发方式访问数据库,数据库中的相同数据可能同时被多个事务访问,如果没有采取必要的隔离措施,就会导致各种并发问题,破坏数据的完整性。

    并发问题归结:数据问题(脏读、幻读、不可重复读)、数据更新问题(更新丢失)

     

     

    一、【存储过程的概念】

    ① 存储过程(Stored Procedure)是一组为了完成特定功能的SQL语句集。经编译后存储在数据库中。

    ② 存储过程是数据库中的一个重要对象,用户通过指定存储过程的名字并给出参数(可以有参数,也可以没有)来执行它。

    ③ 存储过程是由 流控制 和 SQL语句书写的过程,这个过程经编译和优化后存储在数据库服务器中。

    ④ 存储过程 可由应用程序通过一个调用来执行,而且允许用户声明变量。

    ⑤ 同时,存储过程可以接收和输出参数、返回执行存储过程的状态值,也可以嵌套调用。

    二、【存储过程的优点】

    ① 存储过程的使用大大增强了SQL语言的功能和灵活性。

    存储过程可以用流控制语句编写,有很强的灵活性,可以完成复杂的判断和较复杂的运算。

    ② 可保证数据的安全性和完整性。

    通过存储过程可以使没有权限的用户在控制之下间接地存取数据库,从而保证数据的安全。

    通过存储过程可以使相关的动作在一起发生,从而可以维护数据库的完整性。(就像事务的原子性:要么事务内的所有SQL语句全部执行成功,要么全部不成功)

    ③ 在运行存储过程前,数据库已对其进行了语法和句法分析,并给出了优化执行方案。

    这种已经编译好的过程可极大地改善SQL语句的性能。

    由于执行SQL语句的大部分工作已经完成(因为已经提前经过编译),所以存储过程能以极快的速度执行。

    ④ 可以降低网络的通信量。

    客户端调用存储过程只需要传存储过程名和相关参数即可,与传输SQL语句相比自然数据量少了很多(在远程访问时体现出来)。

    ⑤ 存储过程只在创造时进行编译,以后每次执行存储过程都不需再重新编译,而一般SQL语句每执行一次就编译一次,所以使用存储过程可提高数据库执行速度。

    ⑥ 当对数据库进行复杂操作时(如对多个表进行Update,Insert,Query,Delete时),可将此复杂操作用存储过程封装起来与数据库提供的事务处理结合一起使用。

    比如每一步对数据库的操作用一个事务来完成,把这些事务全都放在一个存储过程中。

    ⑦ 存储过程可以重复使用,可减少数据库开发人员的工作量。

    ⑧ 安全性高,可设定只有某些用户才具有对指定存储过程的使用权

    三、【存储过程缺点】

    ① 调试麻烦:但是用 PL/SQL Developer 调试很方便!弥补这个缺点。

    ② 移植问题:数据库端代码当然是与数据库相关的。但是如果是做工程型项目,基本不存在移植问题。

    ③ 重新编译问题:因为后端代码是运行前编译的,如果带有引用关系的对象发生改变时,受影响的存储过程、包将需要重新编译(不过也可以设置成运行时刻自动编译)。

    比如A存储过程调用B存储过程,使用B的返回值作为参数,如果B的参数或返回值发生改变时,会对调用她的A产生影响,此时存储过程就要重新编译,设置成运行时刻自动编译。

    ④ 维护比较困难:如果在一个程序系统中大量的使用存储过程,到程序交付使用的时候随着用户需求的增加会导致数据结构的变化,接着就是系统的相关问题了,最后如果用户想维护该系统可以说是很难很难、而且代价是空前的,维护起来更麻烦。

    四、【存储过程的种类】

    ① 系统存储过程:一般以sp_开头,用来进行系统的各项设定,获取配置信息,相关管理工作。

    ② 本地存储过程:用户创建的存储过程是由用户创建并完成某一特定功能的存储过程,事实上一般所说的存储过程就是指本地存储过程。

    ③ 临时存储过程:分为两种存储过程:

    一是本地临时存储过程,以井字号(#)作为其名称的第一个字符,则该存储过程将成为一个存放在tempdb数据库中的本地临时存储过程,且只有创建它的用户才能执行它;

    二是全局临时存储过程,以两个井字号(##)号开始,则该存储过程将成为一个存储在tempdb数据库中的全局临时存储过程,全局临时存储过程一旦创建,以后连接到服务器的任意用户都可以执行它,而且不需要特定的权限。

    ④ 远程存储过程:在SQL Server2005中,远程存储过程(Remote Stored Procedures)是位于远程服务器上的存储过程,通常可以使用分布式查询和EXECUTE命令(在SQL*Plus命令行窗口中)执行一个远程存储过程。

    ⑤ 扩展存储过程:扩展存储过程(Extended Stored Procedures)是用户可以使用外部程序语言编写的存储过程,而且扩展存储过程的名称通常以xp_开头。

    五、【存储过程的特性】

    1.存储过程与函数的区别

    ①返回值:函数只能返回一个变量,而存储过程可以返回多个。对于存储过程来说可以返回参数,如记录集,而函数只能返回值或者表对象

     ②存储过程一般是作为一个独立的部分来执行( EXECUTE 语句执行),而函数可以作为查询语句的一个部分来调用(SELECT调用),由于函数可以返回一个表对象,因此它可以在查询语句中位于FROM关键字的后面。 SQL语句中不可用存储过程,而可以使用函数。 

    ③存储过程实现的功能要复杂一点,而函数的实现的功能针对性比较强,比较单一。

    2.存储过程与事务的区别

    ①存储位置:事务在程序中被调用,保存在调用以及实现它的代码中,存储过程可以在数据库客户端直接被调用,经编译后存储在数据库中。

    ②运行方式:事务在每次被调用的时候执行其中的SQL语句,存储过程预先经过编译,并不是每次被调用时都会执行一遍其中的SQL语句。

    ③事务有严格的一致性和原子性,使用的安全性高,存储过程则没有这些特性,在进行一些复杂的操作时,为了保证操作的准确性,可以在存储过程中调用事务,然后判断事务的执行结果是否成功来确保操作的准确性。

    3.触发器

    ①概念及作用

    触发器是一种特殊类型的存储过程,它不同于我们前面介绍过的存储过程。触发器主要是通过事件进行触发而被执行的,而存储过程可以通过存储过程名字而被直接调用。当对某一表进行诸如Update、 Insert、 Delete 这些操作时,SQL Server就会自动执行触发器所定义的SQL 语句,从而确保对数据的处理必须符合由这些SQL 语句所定义的规则。

    触发器的主要作用就是其能够实现由主键和外键所不能保证的复杂的参照完整性和数据的一致性。除此之外,触发器还有其它许多不同的功能:

    (1) 强化约束(Enforce restriction)

    触发器能够实现比CHECK 语句更为复杂的约束。

    (2) 跟踪变化(Auditing changes)

    触发器可以侦测数据库内的操作,从而不允许数据库中未经许可的指定更新和变化。

    (3) 级联运行(Cascaded operation)。

    触发器可以侦测数据库内的操作,并自动地级联影响整个数据库的各项内容。例如,某个表上的触发器中包含有对另外一个表的数据操作(如删除,更新,插入)而该操作又导致该表上触发器被触发。

    (4) 存储过程的调用(Stored procedure invocation)。

    为了响应数据库更新,触发器可以调用一个或多个存储过程,甚至可以通过外部过程的调用而在DBMS(数据库管理系统)本身之外进行操作。

    由此可见,触发器可以解决高级形式的业务规则或复杂行为限制以及实现定制记录等一些方面的问题。例如,触发器能够找出某一表在数据修改前后状态发生的差异,并根据这种差异执行一定的处理。此外一个表的同一类(Insert、 Update、Delete)的多个触发器能够对同一种数据操作采取多种不同的处理。

    总体而言,触发器性能通常比较低。当运行触发器时,系统处理的大部分时间花费在参照其它表的这一处理上,因为这些表既不在内存中也不在数据库设备上,而删除表和插入表总是位于内存中。可见触发器所参照的其它表的位置决定了操作要花费的时间长短。

     

     

     

    更多相关内容
  • 【数据库】视图 存储过程 触发器 事物

    千次阅读 热门讨论 2016-05-25 17:19:48
    视频终于结束了,下面是对视频20集的总结,思维导图的思路首从...为了实现数据库操作的高效以及完整性,我么引入了视图,存储过程,触发器,事物系列的操作,下面就说一下我对视图,存储过程 触发器以及事物的理解

    视频终于结束了,下面是对视频20集的总结,思维导图的思路首从建立以及操作数据库开始,有了数据库之后,我们就要在数据库中建立表,对表的操作我们需要通过编程语句来实现,最后就是要保证数据的安全性,其中包括备份。




    为了实现数据库操作的高效以及完整性,我么引入了视图,存储过程,触发器,事物等一系列的操作,下面就说一下我对视图,存储过程 触发器以及事物的理解


    一:视图

     

    1.视图是一张虚拟的表,字段可以由我们自己定义,视图查询出来的数据只能进行查看,不能增删改

     

    2.作用

    通过视图可以把我们想查询的信息显示在一个表里,为减少数据冗余只存放基本信息,可是当想看更细的信息的时候需要多表之间的联系,为了少写select语句,我们就要在多个表中创建视图。


    3.应用举例

    下面我们敲学生时用到的三张表,分别是学籍表,班级表,年级课程表





    我们想了解一个学生所选择的课程,假如每张表中存放了100000条记录,现在有三张表,每张表都执行查询,那么程序的性能是否会下降,查询的效率是否会很低?
    基于这样的考虑,我们就想到用视图,让不同的表中的信息在一张表中显示出来,这样可以减少查询的次数,以提高程序的性能。


    创建视图步骤:

    1.先联合学籍,班级表:

    select a.student_ID,a.student_name,a.class_no,b.grade from 学籍表a,班级表b where a.class_no=b.classno


    2.得到的表再联合上年级课程表

    select a.student_ID,a.student_name,a.class_no,b.grade,c.course_name from 学籍表a,班级表b,年级课程表c where a.class_no=b.classno and b.grade=c.grade_id


    3.创建视图

    这样我们就可以得到一个包含学号,姓名,班号,年级,课程的新的表,我们需要为查询到的结果建立一个视图,等再次查看的时候调用这个视图就可以,减少查询量。下面是视图的创建:

    create view table_1(

    select a.student_ID,a.student_name,a.class_no,b.grade,c.course_name from 学籍表a,班级表b,年级课程表c where a.class_no=b.classno and b.grade=c.grade_id)


    二:存储过程:

    1.存储过程相当于自定义函数,可以被调用,存储过程是一系列预先编辑好的,能实现特定操作功能的SQL代码集,他与特定数据库相关联,存储在SQL Server服务器上


    2.优点


    3.应用举例:

      定义一个存储过程:从员工信息表和部门信息表中返回员工信息。

      Create proc p_enployee

      @departementid varchar(10),      

      @zhiwei varchar(20)

      As

         Select A.员工姓名,A.性别,A.所任职位,A.联系电话,B.部门名称

         From 员工信息 A, 部门信息 B

        Where A.所在部门编号=B.部门编号 AND B.部门编号=@departmentid  AND A.所任      职位=@zhiwei

     

       调用存储过程:

       Exec p_employee @departmentid=’10001’,@zhiwei=’主管’


    三:触发器

    1.触发器是一种特殊类型的存储过程,它在指定的表中的数据发生变化时自动生效。唤     醒调用触发器以响应 INSERT、UPDATE 或 DELETE 语句。触发器是当我们执行触发器中定义的操时,主动工作。


    2.应用举例:

    定义一个update的触发器


    执行update操作:

    Update 姓名,年龄,家庭住址

    当执行update操作时,会触发这个触发器,此触发器执行的功能是如果更改姓名和性别,则会显示事物不能被处理,然后回滚此次操作,也就是说教师信息表里的数据除了姓名和性别两列之外,都可以更改,然后会显示数据修改成功。

    四:事物:

    1.是指一个操作序列,要么都被执行,要么都不被执行,不可分割,事物即使指我们可以预先推测出这个地方可能会发生错误,如果发生错误则把前面执行的操作全部取消,这时就需要定义一个事物处理过程,用来回滚事物,让程序回到没有操作之前的状态,


    2.应用举例:

    小明要向小红转100块钱,此时银行需要做的事情就是:

    一:小红卡里多100块钱

    二:小明卡里少100块

    这样才算交易成功,但是如果小明卡里多了100,而小红卡里的钱没有少,这是就会产生错误,这时就需要定义一个事物用于回滚到交易之前的状态,即与交易相关的所有数据库信息也成功地更新。但是,如果在这一系列过程中任何一个环节出了差错,例如在更新小明卡里的余额信息时发生异常、这将导致交易失败。一旦交易失败,数据库中所有信息都必须保持交易前的状态不变,比如最后一步在更新小明卡里的余额失败而导致交易失败,那么必须保证这笔失败的交易不影响数据库的状态--库存信息没有被更新、用户也没有付款,订单也没有生成。否则,数据库的信息将会一片混乱。


    下面我们定义了一个事物,输入学生信息,如果输入是汉族,则继续执行操作,否则回滚事物,即不添加此学生的信息,使系统信息回到添加此学生信息之前的状态。


    总结上面对于这些概念的理解只是表面的一些东西,还没有深层次应用过吗不过相信学习是一个循序渐进的过程,现在对于一些理解的不是太透彻,在以后的学习过程中会不断深刻,相信自己。





    展开全文
  • 项目右键 Manage NuGet Packages for Solution 搜索Dapper ->...它可以执行次或次命令并返回受影响的行数。此方法通常用于执行。 ● 存储过程 ● Insert语句 ● Update 语句 ● Delete 语句 存储过...

    Dapper_w3cschool【异步,缓冲,事物,存储过程】
    SQL Server 存储过程使用   (其中包括 Dapper调用存储过程 示例)

    项目右键 Manage NuGet Packages for Solution

    搜索Dapper -> Install 

    Dapper Execute
    Execute 是一种扩展方法,可以从IDbConnection类型的任何对象调用。它可以执行一次或多次命令并返回受影响的行数。此方法通常用于执行。
    ● 存储过程
    ● Insert语句
    ● Update 语句
    ● Delete 语句

    返回“新增自增主键ID”,“统计个数”:ExecuteScalar<int>

    _conn.ExecuteScalar<int>("insert into 表名 (name) vaule (@name);SELECT @@IDENTITY;", new { name="dage" });



    存储过程示例
    conn.Execute("", new { }, null, null, System.Data.CommandType.StoredProcedure);

    多个结果集存储过程【proc_multiple_select】

    CREATE PROCEDURE [dbo].[proc_multiple_select]
      @page int,
      @per_page int,
      @total int output,
      @page_count int output
    AS
    BEGIN
        declare @sql_total_string nvarchar(2000) 
    	declare @skip int
    
    	set @skip = (case when @page - 1 <= 0 then 0 else @page - 1 end) * @per_page
    
    	select * from sys_department
    	select * from sys_user
    
    	set @sql_total_string = N'select @total = count(*) from sys_department'
    	exec sp_executesql @sql_total_string,N'@total int out',@total output
    	set @page_count = ceiling(@total * 1.0 / @per_page)
    END

    项目实战【增,删,改,查询1条,查询多条,存储过程,QueryMultiple多个结果集】

    using System;
    using System.Collections.Generic;
    using System.Configuration;
    using System.Data;
    using System.Data.SqlClient;
    using System.Linq;
    
    namespace Dapper.Repository
    {
        public class DapperDemo
        {
            public static string ConnectionString
            {
                get
                {
                    string _connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ToString();
                    return _connectionString;
                }
            }
    
            public SqlConnection OpenConnection()
            {
                SqlConnection connection = new SqlConnection(ConnectionString);
                connection.Open();
                return connection;
            }
    
            /// <summary>
            /// 添加
            /// </summary>
            /// <returns></returns>
            public bool Add()
            {
                int row = 0;
                ED_Data model = new ED_Data();
                model.TableName = "123";
                model.DataKey = "123";
                model.FieldName = "123";
                model.Value = "123";
                model.Reference = "123";
                model.Branch = 1;
                model.InActive = false;
                model.Updated = DateTime.Now;
    
                string query = "INSERT INTO ED_Data(TableName,DataKey,FieldName,Value,Reference,Branch,InActive,Updated) VALUES (@TableName,@DataKey,@FieldName,@Value,@Reference,@Branch,@InActive,@Updated)";
                using (IDbConnection conn = OpenConnection())
                {
                    row = conn.Execute(query, model);
                }
                if (row > 0)
                    return true;
                else
                    return false;
            }
    
            /// <summary>
            /// 修改
            /// </summary>
            /// <returns></returns>
            public int Update()
            {
                int row = 0;
                ED_Data model = new ED_Data();
                model.TableName = "123";
                model.DataKey = "123";
                model.Updated = DateTime.Now;
                using (IDbConnection conn = OpenConnection())
                {
                    const string query = "UPDATE ED_Data SET DataKey=@DataKey,Updated=@Updated WHERE TableName=@TableName";
                    row = conn.Execute(query, model);
                }
                return row;
            }
    
            /// <summary>
            /// 删除
            /// </summary>
            /// <returns></returns>
            public int Delete()
            {
                int row = 0;
                ED_Data model = new ED_Data();
                model.TableName = "123";
                using (IDbConnection conn = OpenConnection())
                {
                    const string query = "DELETE FROM ED_Data WHERE TableName=@TableName";
                    row = conn.Execute(query, model);
                }
                return row;
            }
    
            /// <summary>
            /// 查询一条数据
            /// </summary>
            /// <param name="columnCatId"></param>
            /// <returns>ED_Data</returns>
            public ED_Data GetModel(string TableName)
            {
                using (IDbConnection conn = OpenConnection())
                {
                    const string query = "SELECT * FROM ED_Data WHERE TableName = @TableName";
                    return conn.Query<ED_Data>(query, new { tableName = TableName }).SingleOrDefault<ED_Data>();
                }
            }
    
            /// <summary>
            /// 查询list集合
            /// </summary>
            /// <returns>List</returns>
            public List<ED_Data> GetED_DataList()
            {
                using (IDbConnection conn = OpenConnection())
                {
                    const string query = "SELECT * FROM ED_Data";
                    return conn.Query<ED_Data>(query, null).ToList();
                }
            }
    
            /// <summary>
            /// 查询list集合【多个结果集】
            /// </summary>
            /// <returns>List</returns>
            public List<DepartmentDto> GetED_DataList()
            {
                using (IDbConnection conn = OpenConnection())
                {
                    const string sql = "select * from sys_department;select count(*) department_code from sys_department;";
                    var multiple = conn.QueryMultiple(sql);
                    List<DepartmentDto> list = multiple.Read<DepartmentDto>().ToList();
                    var total = multiple.Read<DepartmentDto>().FirstOrDefault().department_code;
                    return list;
                }
            }
    
            /// <summary>
            /// 查询list集合【多个结果集】【存储过程】
            /// </summary>
            /// <returns>List</returns>
            public List<DepartmentDto> GetDepartmentList()
            {
                DynamicParameters para = new DynamicParameters();
                para.Add("@page", page.page);
                para.Add("@per_page", page.per_page);
                para.Add("@total", 0, DbType.Int32, ParameterDirection.Output);
                para.Add("@page_count", 0, DbType.Int32, ParameterDirection.Output);
    
                using (IDbConnection conn = OpenConnection())
                {
                    var multiple = conn.QueryMultiple("proc_multiple_select", para, commandType: CommandType.StoredProcedure);
                    List<DepartmentDto> list = multiple.Read<DepartmentDto>().ToList();
                    List<UserDto> listUser = multiple.Read<UserDto>().ToList();
                    total = para.Get<int>("@total");
                    pageCount = para.Get<int>("@page_count");
                    return list;
                }
            }
    
            /// <summary>
            /// 事务处理
            /// 删除
            /// </summary>
            /// <param name="cat"></param>
            /// <returns></returns>
            public int DeleteColumnCatAndColumn(ED_Data cat)
            {
                try
                {
                    using (IDbConnection conn = OpenConnection())
                    {
                        string delete1 = "DELETE FROM ED_Data WHERE TableName=@TableName";
                        string delete2 = "DELETE FROM ED_Data WHERE TableName=@TableName";
    
                        IDbTransaction transaction = conn.BeginTransaction();
                        int row = conn.Execute(delete1, new { TableName = cat.TableName }, transaction, null, null);
                        row += conn.Execute(delete2, new { TableName = cat.TableName }, transaction, null, null);
                        transaction.Commit();
                        return row;
                    }
                }
                catch (Exception)
                {
                    throw;
                }
            }
            
            /// <summary>
            /// 执行存储过程
            /// </summary>
            public void ExecuteStoredProcedure()
            {
                try
                {
                    DynamicParameters para = new DynamicParameters();
                    para.Add("@param1", 1);
                    para.Add("@param2", 2);
    
                    using (IDbConnection conn = OpenConnection())
                    {
                        int row = conn.Execute("存储过程名称", para, null, null, CommandType.StoredProcedure);
                    }
                }
                catch (Exception)
                {
                    throw;
                }
            }
    
            /// <summary>
            /// 新增,返回主键ID值【存储过程】
            /// </summary>
            public int Create(CreateBroadcastRequest data)
            {
                int code = 0;
                DynamicParameters para = new DynamicParameters();
                para.Add("@broadcast_code", 0, DbType.Int32, ParameterDirection.Output);
                para.Add("@contents", data.contents);
                _conn.Execute("存储过程名称", para, commandType: CommandType.StoredProcedure);
                code = para.Get<int>("@broadcast_code");
                return code;
            }
    
            /// <summary>
            /// 批量添加
            /// </summary>
            public void InsertBatch()
            {
                try
                {
                    string sqlStr = "INSERT INTO ED_Data(TableName,DataKey,FieldName,Value,Reference,Branch,InActive,Updated) VALUES (@TableName,@DataKey,@FieldName,@Value,@Reference,@Branch,@InActive,@Updated)";
                    using (IDbConnection conn = OpenConnection())
                    {
                        conn.Execute(sqlStr, new[] 
                        {
                            new { TableName = "user1", DataKey = "a", FieldName = "name", Value = "000001", Reference = "", Branch = "", InActive = "", Updated = DateTime.Now },
                            new { TableName = "user2", DataKey = "b", FieldName = "age", Value = "000002", Reference = "", Branch= "", InActive = "", Updated = DateTime.Now },
                            new { TableName = "user3", DataKey = "c", FieldName = "phone", Value = "000003", Reference= "", Branch= "", InActive= "", Updated= DateTime.Now },
                        }, null, null, null);
                    }
                }
                catch (Exception)
                {
                    throw;
                }
            }
        }
    }
    

    *

    using System;
    using System.Collections.Generic;
    using System.Configuration;
    using System.Data;
    using System.Data.SqlClient;
    using System.Linq;
    
    namespace Dapper.Repository
    {
        public class ED_Data
        {
            public string TableName { get; set; }
    
            public string DataKey { get; set; }
    
            public string FieldName { get; set; }
    
            public string Value { get; set; }
    
            public string Reference { get; set; }
    
            public int Branch { get; set; }
    
            public bool InActive { get; set; }
    
            public DateTime Updated { get; set; }
        }
    }
    

    Base基类

    using Dapper.CoreLibrary;
    using Dapper.Entity;
    using System;
    using System.Collections.Generic;
    using System.Data;
    using System.Linq;
    using System.Reflection;
    using System.Text;
    using System.Transactions;
    
    namespace Dapper.Repository
    {
        public abstract class RepositoryBase<T> : DbConnectionFactory, IRepositoryBase<T> where T : IEntityBase<T>
        {
            public RepositoryBase(IDbConnection db) : base(db) { }
    
            /// <summary>
            /// 
            /// </summary>
            /// <param name="model"></param>
            /// <returns></returns>
            public virtual int Add(T model)
            {
                int result = 0;
                try
                {
                    var ps = model.GetType().GetProperties();
                    List<string> @colms = new List<string>();
                    List<string> @params = new List<string>();
                    foreach (var p in ps)
                    {
                        if (!p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute)) && !p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute)))
                        {
                            @colms.Add(string.Format("[{0}]", p.Name));
                            @params.Add(string.Format("@{0}", p.Name));
                        }
                    }
                    var sql = string.Format("INSERT INTO [{0}] ({1}) VALUES({2}); SELECT @@IDENTITY;", typeof(T).Name, string.Join(", ", @colms), string.Join(", ", @params));
                    result = _conn.ExecuteScalar<int>(sql, model);
                }
                catch (Exception ex)
                {
                    throw;
                }
                return result;
            }
    
            /// <summary>
            /// 
            /// </summary>
            /// <param name="listModel"></param>
            public virtual void Add(List<T> listModel)
            {
                try
                {
                    using (var scope = new TransactionScope())
                    {
                        listModel.ForEach(model =>
                        {
                            var ps = model.GetType().GetProperties();
                            List<string> @colms = new List<string>();
                            List<string> @params = new List<string>();
                            foreach (var p in ps)
                            {
                                if (!p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute)) && !p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute)))
                                {
                                    @colms.Add(string.Format("[{0}]", p.Name));
                                    @params.Add(string.Format("@{0}", p.Name));
                                }
                            }
                            var sql = string.Format("INSERT INTO [{0}] ({1}) VALUES({2}); SELECT @@IDENTITY;", typeof(T).Name, string.Join(", ", @colms), string.Join(", ", @params));
                            _conn.ExecuteScalar<int>(sql, model);
                        });
                        scope.Complete();
                    }
                }
                catch (Exception ex)
                {
                }
            }
    
            /// <summary>
            /// 
            /// </summary>
            /// <param name="model"></param>
            /// <returns></returns>
            public virtual int AddWithGuid(T model)
            {
                int result = 0;
                try
                {
                    var ps = model.GetType().GetProperties();
                    List<string> @colms = new List<string>();
                    List<string> @params = new List<string>();
                    foreach (var p in ps)
                    {
                        if (!p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute)))
                        {
                            @colms.Add(string.Format("[{0}]", p.Name));
                            @params.Add(string.Format("@{0}", p.Name));
                        }
                    }
                    var sql = string.Format("INSERT INTO [{0}] ({1}) VALUES({2});", typeof(T).Name, string.Join(", ", @colms), string.Join(", ", @params));
                    result = _conn.Execute(sql, model);
                }
                catch (Exception ex)
                {
                    throw;
                }
                return result;
            }
    
            /// <summary>
            /// 
            /// </summary>
            /// <param name="model"></param>
            public virtual void Update(T model)
            {
                PropertyInfo pkInfo = null;
                var ps = model.GetType().GetProperties();
                List<string> @params = new List<string>();
                foreach (var p in ps)
                {
                    if (p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute)))
                    {
                        continue;
                    }
                    if (p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute)))
                    {
                        pkInfo = p;
                    }
                    else
                    {
                        @params.Add(string.Format("[{0}]=@{0}", p.Name));
                    }
                }
                var sql = string.Format("UPDATE [{0}] SET {1} WHERE [{2}] = @{2}", typeof(T).Name, string.Join(", ", @params), pkInfo.Name);
                _conn.Execute(sql, model);
            }
    
            /// <summary>
            /// 
            /// </summary>
            /// <param name="listModel"></param>
            public virtual void Update(List<T> listModel)
            {
                using (var scope = new TransactionScope())
                {
                    listModel.ForEach(model =>
                    {
                        PropertyInfo pkInfo = null;
                        var ps = model.GetType().GetProperties();
                        List<string> @params = new List<string>();
                        foreach (var p in ps)
                        {
                            if (p.CustomAttributes.Any(x => x.AttributeType == typeof(DBIgnoreAttribute)))
                            {
                                continue;
                            }
                            if (p.CustomAttributes.Any(x => x.AttributeType == typeof(PrimaryKeyAttribute)))
                            {
                                pkInfo = p;
                            }
                            else
                            {
                                @params.Add(string.Format("[{0}] = @{0}", p.Name));
                            }
                        }
                        var sql = string.Format("UPDATE [{0}] SET {1} WHERE [{2}] = @{2}", typeof(T).Name, string.Join(", ", @params), pkInfo.Name);
                        _conn.Execute(sql, model);
                    });
                    scope.Complete();
                }
            }
    
            /// <summary>
            /// 
            /// </summary>
            /// <param name="primaryValue">主键ID</param>
            /// <param name="tableName">表名</param>
            /// <returns></returns>
            public virtual T GetModel(string primaryValue, string tableName = "")
            {
                try
                {
                    string primaryWhere = string.Empty;
                    var ps = typeof(T).GetProperties();
                    if (string.IsNullOrEmpty(tableName))
                    {
                        tableName = typeof(T).Name;
                    }
                    var primary = ps.Single(p => p.CustomAttributes.FirstOrDefault(c => c.AttributeType == typeof(PrimaryKeyAttribute)) != null);
    
                    primaryWhere = (string.Format("[{0}] = @primarykey", primary.Name));
    
                    var sql = string.Format("SELECT * FROM [{0}] WHERE {1}", tableName, primaryWhere);
    
                    return _conn.Query<T>(sql, new { primarykey = primaryValue }).FirstOrDefault();
                }
                catch (Exception)
                {
    
                    throw;
                }
            }
    
            /// <summary>
            /// 
            /// </summary>
            /// <param name="strWhere">where条件</param>
            /// <param name="tableName">表名</param>
            /// <returns></returns>
            public virtual T GetModelQuery(string strWhere, string tableName = "")
            {
                try
                {
                    var sql = string.Format("SELECT * FROM [{0}] WHERE {1}", tableName, strWhere);
                    return _conn.Query<T>(sql, new { where = strWhere }).FirstOrDefault();
                }
                catch (Exception)
                {
                    throw;
                }
            }
    
            /// <summary>
            /// 根据主键删除
            /// </summary>
            /// <param name="primaryValue"></param>
            public virtual void Delete(string primaryValue)
            {
                try
                {
                    string primaryWhere = string.Empty;
                    var ps = typeof(T).GetProperties();
                    var primary = ps.Single(p => p.CustomAttributes.FirstOrDefault(c => c.AttributeType == typeof(PrimaryKeyAttribute)) != null);
                    var sql = string.Format("DELETE FROM [{0}] WHERE {1} = @primarykey", typeof(T).Name, primary.Name);
                    _conn.Execute(sql, new { primarykey = primaryValue });
                }
                catch (Exception)
                {
                    throw;
                }
            }
    
            /// <summary>
            /// 
            /// </summary>
            /// <param name="strWhere"></param>
            public void DeleteStrWhere(string strWhere)
            {
                try
                {
                    var sql = string.Format("DELETE FROM [{0}] WHERE {1}", typeof(T).Name, strWhere);
                    _conn.Execute(sql);
                }
                catch (Exception)
                {
                    throw;
                }
            }
    
            /// <summary>
            /// 
            /// </summary>
            /// <param name="strWhere"></param>
            /// <param name="tableName"></param>
            /// <returns></returns>
            public virtual List<T> GetList(string strWhere, string tableName = "")
            {
                try
                {
                    if (string.IsNullOrEmpty(tableName))
                        tableName = typeof(T).Name;
                    var sql = string.Format("SELECT * FROM [{0}] " + (strWhere == "" ? "" : " WHERE " + " {1} "), tableName, strWhere);
                    return _conn.Query<T>(sql).ToList();
                }
                catch (Exception)
                {
                    throw;
                }
            }
    
            /// <summary>
            /// 
            /// </summary>
            /// <param name="param"></param>
            /// <returns></returns>
            public virtual PagerListResult<List<T>> GetPageList(PagerRequestParam param)
            {
                PagerListResult<List<T>> result = null;
                List<T> list = new List<T>();
                int pageTotal = 1;
                int recordTotal = 0;
                int startIndex = 1;
                int endIndex = param.PageSize;
                try
                {
                    if (param.PageIndex - 1 > 0)
                    {
                        startIndex = (param.PageIndex - 1 <= 0 ? 1 : param.PageIndex - 1) * param.PageSize + 1;
                        endIndex = param.PageIndex * param.PageSize;
                    }
    
                    if (string.IsNullOrEmpty(param.TableName))
                        param.TableName = typeof(T).Name;
                    StringBuilder strSql = new StringBuilder();
                    strSql.Append("SELECT * FROM ( ");
                    strSql.Append(" SELECT ROW_NUMBER() OVER (");
                    if (!string.IsNullOrEmpty(param.OrderBy))
                    {
                        strSql.Append("ORDER BY T." + param.OrderBy);
                    }
                    else
                    {
                        strSql.Append("ORDER BY T.ID DESC");
                    }
                    strSql.Append(")AS Row, T.*  FROM " + param.TableName + " T ");
                    if (!string.IsNullOrEmpty(param.StrWhere))
                    {
                        strSql.Append(" WHERE " + param.StrWhere);
                    }
                    strSql.Append(" ) TT");
                    strSql.AppendFormat(" WHERE TT.Row BETWEEN {0} AND {1}", startIndex, endIndex);
    
                    list = _conn.Query<T>(strSql.ToString(), param.StrWhere).ToList();
                    if (list.Count > 0)
                    {
                        recordTotal = this.GetRecordCount(param.StrWhere, param.TableName);
                        pageTotal = PagerRequestParam.Tool.PageTotal(param);
                    }
                    result = new PagerListResult<List<T>>(list, pageTotal, recordTotal);
                }
                catch (Exception ex)
                {
                    result = new PagerListResult<List<T>>(ex);
                }
                return result;
            }
    
            /// <summary>
            /// 事务处理
            /// Demo
            /// </summary>
            /// <returns></returns>
            public int DeleteTransaction()
            {
                try
                {
                    const string delete1 = "DELETE FROM ED_Data WHERE TableName=@TableName";
                    const string delete2 = "DELETE FROM ED_Data WHERE TableName=@TableName";
    
                    IDbTransaction transaction = _conn.BeginTransaction();
                    int row = _conn.Execute(delete1, new { TableName = "user" }, transaction, null, null);
                    row += _conn.Execute(delete2, new { TableName = "customer" }, transaction, null, null);
                    transaction.Commit();
                    return row;
                }
                catch (Exception)
                {
                    throw;
                }
            }
    
            /// <summary>
            /// 获取记录数count()统计
            /// </summary>
            /// <param name="strWhere">Where条件</param>
            /// <returns></returns>
            public virtual int GetRecordCount(string strWhere, string tableName = "")
            {
                int count = 0;
                try
                {
                    if (string.IsNullOrEmpty(tableName))
                        tableName = typeof(T).Name;
                    StringBuilder strSql = new StringBuilder();
                    strSql.Append("SELECT COUNT(1) FROM " + tableName);
                    if (!string.IsNullOrEmpty(strWhere))
                    {
                        strSql.Append(" WHERE " + strWhere);
                    }
                    count = _conn.ExecuteScalar<int>(strSql.ToString());
                }
                catch (Exception)
                {
    
                    throw;
                }
                return count;
            }
        }
    }
    

     

    展开全文
  • 当需要在存储过程中同时执行条添加、修改、删除SQL语句时,为了保证数据完整性,我们需要使用事务。使用方式和在PL-SQL中非常相似,但也有一些区别。  --带事务的存储过程 CREATE OR REPLACE PROCEDURE ...

     

    Oracle基础 存储过程和事务

    一、事务和存储过程

      在存储过程中如何使用事务。当需要在存储过程中同时执行多条添加、修改、删除SQL语句时,为了保证数据完整性,我们需要使用事务。使用方式和在PL-SQL中非常相似,但也有一些区别。  

    复制代码

    --带事务的存储过程
    CREATE OR REPLACE PROCEDURE Account_zhuanzhang(fromuser NUMBER,touser NUMBER,money NUMBER) IS
    BEGIN
        UPDATE account SET balance = balance - money WHERE id = fromuser;
        UPDATE account SET balance = balance + money WHERE id = touser;
        COMMIT;
    EXCEPTION
      WHEN OTHERS THEN
        dbms_output.put_line('转账失败');
        ROLLBACK;
    END Account_zhuanzhang;

    复制代码

    调用事务

    复制代码

    SELECT * FROM ACCOUNT;
    DECLARE 
      fromuser NUMBER := 1;
      touser NUMBER := 2;
      money NUMBER := &m;
    BEGIN
      account_zhuanzhang(fromuser,touser,money);
    END;

    复制代码

     

     

    二、自主事务处理:

      自主事务:是由零一个事务启动的独立事务处理。自主事务处理可以暂停主事务处理,也就是处理自己存储过程内部的事务,当自主事务处理完之后会恢复主事务处理。

      PRAGMA AUTONOMOUS_TRANSACTION;  --定义为自主事务,不受其他事务提交,回滚的影响

      例:

    复制代码

    --自主事务:带参数添加部门信息,最后使用了回滚
    CREATE OR REPLACE PROCEDURE PRO_DEPT_ADD(DEPTNO NUMBER,DNAME VARCHAR2,LOC VARCHAR2) AS
    PRAGMA AUTONOMOUS_TRANSACTION;  --定义为自主事务,不受其他事务提交,回滚影响
    BEGIN
      INSERT INTO DEPT (DEPTNO, DNAME, LOC) VALUES (DEPTNO, DNAME, LOC);
        ROLLBACK;  --自主事务回滚操作,不影响主事务。
    END;

    复制代码

    复制代码

    --主事务,添加部门信息,并调用带参数的自主事务,自己本身提交
    CREATE OR REPLACE PROCEDURE PRO_DEPT_ADD2 AS
    BEGIN
      INSERT INTO DEPT (DEPTNO, DNAME, LOC) VALUES (60, 'test1', 'test2');
      PRO_DEPT_ADD(70, 'test', 'test');     --如果调用的事务回滚,如果不是自主事务当前存储过程中插入数据也要一起回滚。但是添加了自主事务后,自主事务提交内容不会影响到当前存储过程
      COMMIT;
    END;

    复制代码

    调用主事务:

    BEGIN
          pro_dept_add2();  --调用完毕后,为60的部门插入成功,但是为70的部门信息回滚了。只有一条插入成功!
    END;

     

      总结自主事务:

      1、自主事务处理结果的变化不依赖于主事务处理的状态或最终配置。

      2、自主事务处理提交或回滚时,不影响主事务处理的结果。

      3、自主事务提交一旦提交,该自主事务处理结果的变化对于其他事务处理就是课件的。这意味着,用于可以访问已更新的信息,无需等待主事务处理提交。

      4、自主事务处理可以启动其它自主事务处理。

     

    分类: Oracle

    标签: oracle

    好文要顶 关注我 收藏该文  

    Builder
    关注 - 17
    粉丝 - 51

    +加关注

    1

    1

    « 上一篇:Oracle基础 存储过程和游标
    » 下一篇:Oracle基础 自定义函数

    https://www.cnblogs.com/zhengcheng/p/4217531.html

     

     

     

     

    存储过程中如何使用事务Transaction

    学习也休闲 学习也休闲 2014-08-16 13:21:54

    一、Begin Trans、Rollback Trans、Commit Trans方法


    1、用于事务处理的方法。BeginTrans用于开始一个事物;RollbackTrans用于回滚事务;CommitTrans用于提交所有的事务处理结果,即确认事务的处理。


    2、事务处理可以将一组操作视为一个整体,只有全部语句都成功执行后,事务处理才算成功;若其中有一个语句执行失败,则整个处理就算失败,并恢复到处里前的状态。



    二、存储过程中使用事务Transaction实例


     Declare @id int
        BEGIN TRANSACTION
       
           Insert into xxxxxTable(f1,f2)values(@a,@b)
           Select @id=@@identity
            Insert into abcTable(ff1,ff2,ff3)values(@c,@id,@dd)

            IF @@error <> 0 --发生错误
            BEGIN
                ROLLBACK TRANSACTION
                RETURN 0
            END
            ELSE
            BEGIN
                COMMIT TRANSACTION
                RETURN 1 --执行成功
           END



    参考资料: 存储过程中使用事务Transaction http://www.studyofnet.com/news/551.html

    存储过程 事务 Transaction

    https://www.douban.com/note/395757588/

     

    展开全文
  • 如何在oracle SQL语句中调用存储过程

    千次阅读 2021-05-01 03:25:21
    声明部分包含变量和常量的数据类型和初始值. 这部分从关键字DECLARE开始. 如果不需要声明变量或常量,则可以忽略此部分. 应该注意的是,游标的声明也在此部分中.... 在这部分中,将处理异常或...
  • 存储过程中的事务

    千次阅读 2019-04-21 19:56:48
    存储过程中使用事务时非常重要的,使用数据可以保持数据的关联完整性,在Sql server存储过程中使用事务也很简单,用一个例子来说明它的语法格式: 1 Create Procedure MyProcedure 2 3 ( @Param1 nvarchar(10), 4 ...
  • 存储过程和事务区别

    千次阅读 2019-03-12 14:31:41
    首先存储过程一个sql语句集合,事务是指一件事序列化要么全做,要么都不要做,存储过程中可以有事务,事务中也可以有多个存储过程,存储过程方便了功能块的进行,事务保证了功能执行的完整性,但是存储过程不要...
  • PostgreSQL存储过程

    千次阅读 2019-03-07 10:52:32
    PostgreSQL存储过程几年前写过很,但是几年不碰又陌生了,今天给客户写了一个存储过程,查了一些资料,记录一下: –创建测试表 create table student (id integer, name varchar(64)); create table employees ...
  • sqlserver存储过程和触发器

    千次阅读 2019-01-17 11:57:53
    存储过程就是作为可执行对象存放在数据库中的一个多个SQL命令。 通俗来讲:存储过程其实就是能完成一定操作的一组SQL语句。 存储过程的特点,触发器和存储过程的区别,触发器的优点,触发器的作用:实现由主键...
  • sqlserver 存储过程基础关键字

    千次阅读 2020-01-02 17:30:02
    最近要写大量存储过程,这边就介绍下基础...GO:表示一个事物结束的标识,将其GO前面的过程执行完再执行后面的,例: USE [simpleTest] GO 3.SET SET::表示设置,可用于设置参数或者标识,例: SET ANSI_...
  • 2016年07月28日 11:34:15 王涛WantTao 阅读数:2512更 个人分类: ORACLE | PL/SQL 版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/wangtao510/article/details/52053599   ...
  • sql server存储过程 以及几常用案例

    千次阅读 2016-04-23 10:41:08
    SQL Server 存储过程 ...Transact-SQL中的存储过程,非常类似于Java...当存储过程执行次后,可以将语句缓存中,这样下次执行的时候直接使用缓存中的语句。这样就可以提高存储过程的性能。 Ø 存储过程的概念
  • 网上百度了好几篇博客,都没有说明存储过程是什么东西?然后这东西有什么用? 从马克思认识论上来看,我们必须先认识事物是什么东西(即本质),然后才进一步认识事物是用来干嘛的(即属性)。于是,参考了下面...
  • postgreSQL存储过程写法示例

    千次阅读 2017-09-07 16:47:25
    转载自:... PostgreSQL的存储过程简单入门 http://blog.csdn.net/rachel_luo/article/details/8073458  存储过程事物 http://www.php100.com/manual/PostgreSQL8/tutorial-transactions.html
  • mysql存储引擎

    万次阅读 多人点赞 2019-07-31 19:28:44
    数据库存储引擎 数据库存储引擎是数据库底层软件组织,数据库管理系统(DBMS)使用数据引擎进行创建、查询、更新和删除数据。不同的存储引擎提供不同的存储机制、索引技巧、锁定水平等功能,使用不同的存储引擎,还...
  • 需求: 我要存储同时存储一个学生信息和这个学生购买的图书信息,当学生的信息存储失败了,图书信息也不存储了,反之也一样,当某本书的...解决方法: 两个存储用同一个Connection对象。同时在Serivce事物层完成。 第
  • ORACLE存储过程学习(

    千次阅读 2019-03-15 16:10:46
    其实答到这儿的时候,基本上就会有下一个问题,有了解过存储过程,触发器吗?谈到这儿可能很多人都会卡壳,毕竟对于刚要入职的小白来说这两个词汇显得优先生僻了。那么本篇文章,大致跟大家聊一...
  • 存储过程 与 事务管理

    千次阅读 2016-08-03 00:08:51
    个存储过程一个名为ListCount的参数,此参数从存储过程返回一个值,IN、OUT表示这个是传递值还是返回值,调用如下: var ReturnValue NUMBER EXEC MailingListCount(:ReturnValue); SELECT ReturnValue; ...
  • oracle 存储过程以及plsql语句块

    万次阅读 2016-04-13 22:40:41
    1、 PLSQL语法 1.1、程序结构  PL/SQL程序都是以块(block)为基本单位。整个PL/SQL块分三部分:声明...无论PL/SQL程序段的代码量有大,其基本结构就是由这三部分组成。而且每条语句均由分号隔开。 /*
  • 为什么一个byte的存储范围是-128~127?

    万次阅读 多人点赞 2019-11-25 20:15:01
    本文关键字:byte、字节、二进制位、反码、补码。在计算机中,一个二进制位是最小的存储单元,由于是二进制,所以能存储的数字只能是0和1。
  • 详解数据库之存储过程与错误处理

    千次阅读 热门讨论 2013-06-21 17:10:28
    定义: ...存储过程只在创造时进行编译,以后每次执行存储过程都不需再重新编译,而一般SQL语句每执行次就编译次,所以使用存储过程可提高数据库执行速度。  2.当对数据库进行复杂操作时(如对
  • 视图(View)作为一种数据库对象,为用户提供了一个可以检索数据表中的数据方式。用户通过视图来浏览数据表中感兴趣的部分或全部数据,而数据的物理存储位置仍然在表中。 视图是一个虚拟表,并不代表任何物理数据,...
  • 对于这定义,按我个人的看法,就是用计算机语言(不是指百度定义给的c语言c++之类的,而是种更成熟的语言,后面会提到)来完成的脑海中思路的具现化。至于定义中的“求解问题、设计系统和理解人类的行为”,我...
  • 菜鸟学数据库——存储过程

    千次阅读 多人点赞 2012-06-18 21:46:54
    今天继续我们的SQL菜鸟教程,上篇博客说了说触发器... 存储过程(Stored Procedure)是数据库系统中,组为了完成特定功能的SQL 语句集,经编译后存储在数据库中,用户通过指定存储过程的名字并给出参数(如果该存...
  • 触发器与存储过程的区别

    千次阅读 热门讨论 2015-07-20 15:18:23
    看完牛腩前18集,就发现用存储过程和触发器...存储过程: 里面可以有多个SQL语句,用事物可以保证多句语句必须都执行成  功,这个存储过程才执行。 触发器:是在对表进行插入、更新或删除操作时自动执行的存储过程,触
  • 数据库视图、索引、存储过程优缺点 1.视图 (1).什么是视图? 视图(View)作为一种数据库对象,为用户提供了一个可以检索数据表中的数据方式。用户通过视图来浏览数据表中感兴趣的部分或全部数据,而数据的物理...
  • 隔离性:多个事务同时操作,每个事务之间相互独立,互不影响。 持久性:事务提交成功后对数据库的改变是永久的。 (2)数据库三范式 ​ 数据库的范式(规范的数据表示公式):按照什么方式在数据库中表示(存储
  • 数据库中几基本概念 主码 外码

    千次阅读 2021-01-27 21:06:20
    [一 逻辑模型中的信息可以用三个概念来描述:(1) 实体(如果一个对象拥有许多特性和值,那么它可能是个实体)(2) 属性(如果一个对象拥有一个特性的值,那么它可能是属性)主码 ,外码也可以称为主键,外键。什么是主码...
  • mysql触发器与存储过程

    千次阅读 2016-05-04 20:26:20
    外键外键:foreign key,(键不在自己表中):如果一张表中有一个字段(非主键)指向另外一张表的主键,那么将该字段称之为外键。增加外键外键可以在创建表时候,或者创建表之后增加。(但是要考虑数据的问题),一张表...
  • [存储过程]中的事务(rollback)回滚

    千次阅读 2014-05-04 19:28:27
    SQL Server中数据库事务处理是相当有用的,鉴于很SQL初学者编写的事务处理代码存往往存在漏洞,本文我们介绍了三种不同的方法,举例说明了如何在存储过程事务处理中编写正确的代码。希望能够对您有所帮助。 在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 159,933
精华内容 63,973
关键字:

多个存储过程一个事物