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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks

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

全部博文(19283)

文章存档

2011年(1)

2009年(125)

2008年(19094)

2007年(63)

分类:

2008-05-31 23:20:04

学习基本概念

developerWorks



使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155495) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155494) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155493) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155492) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155491) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155490) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155489) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155488) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155487) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155486) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155485) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155484) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155483) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155482) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155481) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155480) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155479) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155478) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155477) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155476) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155475) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155474) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155473) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155472) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155471) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155470) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155469) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155468) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155467) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155466) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155465) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155464) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155463) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155462) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155461) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155460) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155459) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155458) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155457) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155456) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155455) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155454) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155453) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155452) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155451) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155450) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155449) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155448) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155447) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155446) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155445) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~


使用大型对象

一些大型数据对象,例如图像和音频,通常需要存储在数据库中。DB2 为存储大型数据对象提供了专用的数据类型。这些数据类型就是所谓的大型对象(LOB)。在本节中,我们将来探讨一下 LOB。作为一名开发人员,您应该能够存储和检索应用程序中的 LOB。

DB2 提供了三种不同类型的 LOB 数据类型。所有这些数据类型都可以容纳最大为 2 GB 的数据:

  • CLOB —— 包含最大 2 GB 的字符数据
  • BLOB —— 包含最大 2 GB 的二进制数据。实际上,这种二进制数据可以是任何东西(例如图像或音频文件)。
  • Double-Byte Character Large Object (DBCLOB) —— 包含最大 2 GB 的双字节字符数据。注意,只有当创建的数据库为双字节数据进行了配置时,才能使用这种数据类型。
  • XML —— 包含最大 2 GB 的 XML 数据。本教程不讨论 XML,但本系列后面的教程会涉及到这一主题。

LOB 值不存储在数据库表中。在数据库表中存储的实际上是一个描述符。该描述符指向 LOB 的实际位置。实际的 LOB 值存储在表空间中。表空间是物理存储单元。一个 LOB 列中存储的并不是实际的 LOB 数据,而是指向 LOB 数据的一个指针。这种指针被称为“定位符(locator)”。这些所谓的定位符用于表示 LOB 值。当检索一个 ResultSet 中的数据时,实际上是在检索定位符,而不是这些定位符所表示的实际的 LOB 值。必须显式地请求所检索的 LOB 值。这种检索被称为“物化(materialization)”。

当创建一个表时,可以指定 COMPACTNOT COMPACT 选项。如果指定 COMPACT 选项,那么所存储的 LOB 数据占用最少的空间。然而,如果对 LOB 列执行一次更新将增加所存储的 LOB 的大小,那么在性能上要付出代价。另一方面,如果指定 NOT COMPACT(默认),那么 LOB 值实际上还有增长的余地。

如果指定选项 LOGGED,那么对 LOB 列的更新会记录在系统日志中。指定 LOGGED 选项可以为其中的数据提供最大限度的保护,当出现介质故障时,就可用通过一个向前恢复过程重构数据。然而,这也会导致磁盘空间方面的成本(更不用说因将日志写到磁盘而花费的时间成本了)。如果不指定,则默认使用 LOGGED 选项。现在来看一些 Java 中的例子。

PREPAREDSTATEMENT PREPAREDSTATEMENT =  
      CONNECTION.PREPARESTATEMENT("INSERT INTO BOOKCOVERS VALUES(?,?)"); 
FILE IMAGEFILE = NEW FILE("C:\\REDBOOKCOVER.JPG"); 
INPUTSTREAM INPUTSTREAM = NEW FILEINPUTSTREAM(IMAGEFILE); 
PREPAREDSTATEMENT.SETSTRING(1," 0738425826"); 
PREPAREDSTATEMENT.SETBINARYSTREAM(2,INPUTSTREAM,(INT)(IMAGEFILE.LENGTH())); 
PREPAREDSTATEMENT.EXECUTEUPDATE(); 

上述代码片段将 C: 盘根目录中一个名为 redbookcover.jpg 的文件存储到数据库中。注意如何将文件与一个 InputStream 相关联。这个 InputStream 对象用于填充预置语句中 BLOB 列的值。

PREPAREDSTATEMENT PREPAREDSTATEMENT = 
CONNECTION.PREPARESTATEMENT(
   "SELECT BOOKCOVER FROM BOOKCOVERS WHERE BOOKISBN=?"); 
PREPAREDSTATEMENT.SETSTRING(1, "0738425826"); 
RESULTSET RESULTSET = PREPAREDSTATEMENT.EXECUTEQUERY(); 
WHILE (RESULTSET.NEXT()) { 
	// MATERIALIZATION OF THE BLOB 
	BLOB BLOB = RESULTSET.GETBLOB(1); 
	INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM(); 
	FILE FILEOUTPUT = NEW 
	  FILE("C:\\CLONEDREDBOOKCOVER.JPG"); 
	FILEOUTPUTSTREAM FO = NEW
	  FILEOUTPUTSTREAM(FILEOUTPUT); 
	INT C; 
	WHILE ((C = INPUTSTREAM.READ()) != -1) 
	FO.WRITE(C); 
	FO.CLOSE(); 
	SYSTEM.OUT.PRINTLN("BLOB RETRIEVED"); 

在上述 Java 代码片段中,首先执行一个预置语句,该语句选择在前一个代码片段中所插入的 BLOB。需要注意的是,在执行到下面这一行语句之前,实际的 BLOB 还没有被物化:

INPUTSTREAM INPUTSTREAM = BLOB.GETBINARYSTREAM();

输入流用于将检索到的 BLOB 存储到一个名为 clonedredbookcover.jpg 的文件中。检索 CLOB 的语法与检索 BLOB 的语法非常相似。

FILE FILEOUTPUT = ;NEW; 
  FILE("C:\\CLONEDREDBOOKABSTRACT.TXT"); 
FILEOUTPUTSTREAM FO = ;NEW; FILEOUTPUTSTREAM(FILEOUTPUT); 
INPUTSTREAM IS = CLOB.GETASCIISTREAM(); 
INT C; 
WHILE; ((C = IS.READ()) != -1) 
   FO.WRITE(C); 
FO.CLOSE();

在上述 Java 片段中,存储的 CLOB 被物化到一个名为 clonedredbookabstract.txt 的新文件中。这是通过使用 CLOB 的 getAsciiStream 方法来完成的。就像检索 BLOB 那样,将流指定给一个 InputStream,然后从后者读取数据,依次将读取的数据写到 FileOutputStream 中。


阅读(155444) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~