Chinaunix首页 | 论坛 | 博客
  • 博客访问: 109667773
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667778
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667782
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667787
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667794
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667797
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667785
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667806
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667809
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667813
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667816
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667818
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667820
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667823
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667825
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667828
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667832
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667834
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667837
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667839
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667842
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667843
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667846
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667848
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667851
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667853
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667856
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667858
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667860
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667864
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667867
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667870
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667872
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667860
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667877
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667880
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667883
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667884
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667879
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667894
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667897
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667900
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667903
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667890
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667907
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667909
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667912
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667915
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667917
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667905
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667922
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks

DB2 9 应用开发(733 考试)认证指南,第 2 部分: DB2 数据操纵(7)-sdccf-ChinaUnix博客
  • 博客访问: 109667925
  • 博文数量: 19283
  • 博客积分: 9968
  • 博客等级: 上将
  • 技术积分: 196062
  • 用 户 组: 普通用户
  • 注册时间: 2007-02-07 14:28
文章分类

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:19:29

学习基本概念

developerWorks



管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133058) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133057) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133056) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133055) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133054) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133053) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133052) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133051) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133050) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133049) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133048) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133047) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133046) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133045) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133044) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133043) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133042) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133041) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133040) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133039) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133038) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133037) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133036) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133035) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133034) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133033) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133032) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133031) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133030) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133029) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133028) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133027) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133026) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133025) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133024) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133023) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133022) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133021) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133020) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133019) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133018) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133017) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133016) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133015) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133014) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133013) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133012) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133011) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133010) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133009) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133008) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


管理工作单元

术语工作单元(UOW)和事务 的概念是同义的。工作单元被定义为作为单个原子操作执行的 0 到多个 SQL 查询。例如,当客户在 IBM 网站上进行一次在线购物时,必须执行三个步骤:

  1. 必须更新 IBM 网上商店的库存。
  2. 客户必须为所购买的商品付费。
  3. 必须配送客户购买的商品。

如果库存记录已经被更新,并且客户也已经付费,但是却没有创建一个装货单条目,会出现什么情况呢?不但客户会因为没有收到所购买的商品而生气,而且库存也出现了不一致的地方。因此,购买过程中的所有 SQL 查询都必须定义为一个单一的原子操作。

现在来看看一个 DB2 事务中需要有哪些步骤。在开始之前,必须建立与事务所使用的数据库的连接。

以一条可执行语句开始事务。一个事务中总会有一条可执行语句。如果程序在一个事务结束后又出现一条可执行语句,那么它将开始一个新的事务。下面是一些 可执行语句:

BEGIN DECLARE SECTION
END DECLARE SECTION
INCLUDE SQLCA
INCLUDE SQLDA
DECLARE CURSOR
WHENEVER

以以下方式结束事务:

COMMIT
ROLLBACK

COMMIT 语句结束事务,并使更改对其他进程可见。记住,应该定期地执行提交,并且要在程序终止之前单独地执行提交。在 Windows 操作系统中,如果没有显式地提交事务,DB2 将会自动回滚这些事务。在其他操作系统上,DB2 在程序终止期间会自动提交所有未决的事务。

ROLLBACK 语句使数据库回到事务运行之前的状态。回滚可以阻止将之前的事务提交之后的更改应用到数据库。这样可以确保要么事务中所有的操作被提交,要么都不提交。DB2 在以下情况下回滚更改:

  • 日志已满
  • 出现导致系统进程终止的情况

为了避免循环失败,在 ROLLBACK 语句之前使用 WHENEVER SQLWARNING CONTINUEWHENEVER SQLERROR CONTINUEROLLBACK 语句对宿主变量的内容没有影响。

应该采用以下步骤来终止应用程序:

  • 通过 COMMITROLLBACK 结束当前事务。
  • 通过发出 CONNECT RESET 语句释放连接。
  • 释放资源(例如临时存储、数据结构和共享内存等)

在一个应用程序中可以使用多个事务。在一次事务中,可以有多个到数据库的连接。





回页首


编程接口有两种类型的连接:事务型和非事务型。虽然 DB2 支持这两种概念,但是应该清楚,实际上到数据库的连接只有一种 —— 事务型连接。因此,每个 SQL 查询都是事务的一部分。当以非事务方式运行时,所使用的编程接口已经启用了一个称为自动提交(autocommit) 的功能,该功能在每个 SQL 操作完成后隐式地发出一条 COMMIT 语句。如果 UOW 要完成多个查询的话,切记不要启用 autocommit 功能。





回页首


保存点(savepoint)是用于当数据库请求失败时,撤销数据库管理系统(DBMS)所执行的工作的一种机制。保存点使非原子数据库请求行为变成原子的。如果在执行期间发生错误,保存点可用于撤销从事务开始到收到保存点回滚请求这段时间内事务所作出的更改。

保存点便于将多个 SQL 语句组合到单个可执行块中。在这个块中第一个子语句执行之前,需要先发出一个启动保存点块的请求。如果某个子语句发生错误,那么只需回滚那个子语句。这样可以提供比复合 SQL 语句更细的粒度,对于复合 SQL 语句,一个错误就会导致整个块发生错误,并回滚整个复合 SQL 语句。在保存点语句块的最后,可以释放保存点,也可以回滚到保存点。

现在来看一些用于创建和控制保存点的 SQL 语句。要设置一个保存点,可发出 SAVEPOINT SQL 语句。为了使代码更清晰,可以为保存点选择一个更有意义的名称。例如:

SAVEPOINT SAVEPOINT1 ON ROLLBACK RETAIN CURSORS

要释放一个保存点,可发出 RELEASE SAVEPOINT SQL 语句。例如:

RELEASE SAVEPOINT SAVEPOINT1

如果不用 RELEASE SAVEPOINT SQL 语句显式地释放保存点,那么它会在事务的最后自动释放。

要回滚到保存点,可发出 ROLLBACK TO SAVEPOINT SQL 语句。例如:

ROLLBACK TO SAVEPOINT SAVEPOINT1
阅读(133007) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~