yang_B621

C# Oracle数据库连接及操作

壹、ORACLE817安装（服务器端/客户端）... 1

贰、ORACLE817配置（服务器端）... 3

叁、ORACLE817配置（客户端）... 5

肆、安装的oracle8i怎么全部卸载... 8

伍、Oracle数据库体系结构... 10

陆、ORACLE数据类型... 14

柒、c#通过oledb连接Oracle. 27

捌、一个C#操作Oracle的通用类... 29

玖、另一个C#操作Oracle数据库的通用类... 45

拾、C#Oracle连接操作类... 68

壹、ORACLE817安装（服务器端/客户端）

1、将光盘放入光驱，自动弹出安装界面，选择开始安装；

2、欢迎：下一步；

3、文件定位，所有内容默认，如果更改oracle安装路径，在目标路径中进行更改，下一步；

4、可用产品：服务器端选择第一个Oracle8i Enterprise Edition 8.1.7.0.0，客户端选择第二个Oracle8i Client8.1.7.0.0 下一步；

5、安装类型：选择典型（779MB），下一步；

6、数据库标识：全局数据库名：ORA817，SID：ORA817，下一步

7、摘要：安装

8、开始安装…………………….等待

9、安装进度完成后，开始自动配置并启动数据库，继续等待

当弹出下面对话框时，表明ORACLE安装成功

确定并退出

贰、ORACLE817配置（服务器端）

一、登陆ORACLE

开始—>程序—> Oracle-OraHome81—> Database Administration—> DBA Studio

默认，以独立模式启动DBAStudio，点击确定登陆

登陆后，在左面的树形结构中双击我们建立的全局数据库名称，在此为ORA817，登陆用户为internal，口令为oracle，不区分大小写。

二、创建表空间

在左面的树形结构里，选择存储—>表空间，然后点击右键，选择创建，在右面弹出创建表空间的的对话框，名称为JNJWD，大小为500MB，点击创建，完成后弹出提示对话框。

三、创建用户

创建完表空间后，继续点击左面的树形结构，选择安全性—>用户，然后点击右键，选择创建，在右面的一般信息窗口中填写名称：JNJWD，口令：JNJWD，表空间默认值选择JNJWD，切换至角色窗口，配置角色，双击DBA和RESOURCE至下面角色清单中

叁、ORACLE817配置（客户端）

开始—>程序—> Oracle-OraHome81—> Network Administration—> Net8 Assistant

打开Net8后，选择本地—>服务名称，点击右面的绿色加号，创建服务名，弹出向导，在网络服务名中输入JCJXGL，点击下一步

选择TCP/IP网络协议，点击下一步

在协议设置中，填写服务器主机名：服务器的计算机名或IP地址，端口号默认1521不变，点击下一步

在服务设置中，选择通过SID连接服务器，服务器SID为ORA817，Oracle8i连接类型为缺省数据库，默认不变，点击下一步，点击测试弹出测试对话框，默认用户为SCOTT，点击更改登陆，用我们建立的JNJWD用户及口令登陆。测试连接成功，返回并点击完成

导入\导出数据库：

开始—>运行cmd，打开命令提示符状态

导出：EXP JNJWD / JNJWD FILE= JNJWD.DMP回车

导入：IMP JNJWD / JNJWD FROMUSER= JNJWDFILE= JNJWD.DMP

注意：导出数据库时，导出文件将保存在当前提示符前的目录中，导入数据时，首先检查数据文件是否在当前目录，否则先进文件所在路径，然后执行导入命令，或者在文件名前直接加上目录

肆、安装的oracle 8i怎么全部卸载

软件环境：

1、Windows2000+ORACLE 8.1.7

2、ORACLE安装路径为：C:\ORACLE

实现方法：

1、开始－＞设置－＞控制面板－＞管理工具－＞服务

停止所有Oracle服务。

2、开始－＞程序－＞Oracle - OraHome81－＞Oracle InstallationProducts－＞

Universal Installer

卸装所有Oracle产品，但Universal Installer本身不能被删除

5、运行regedit，选择HKEY_LOCAL_MACHINE\SOFTWARE\ORACLE，按del键删除这个入口。

6、运行regedit，选择HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services，滚动

这个列表，删除所有Oracle入口。

7、运行refedit，

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Eventlog\Application，

删除所有Oracle入口。

8、开始－＞设置－＞控制面板－＞系统－＞高级－＞环境变量

删除环境变量CLASSPATH和PATH中有关Oracle的设定

9、从桌面上、STARTUP（启动）组、程序菜单中，删除所有有关Oracle的组和图标

10、删除\ProgramFiles\Oracle目录

11、重新启动计算机，重起后才能完全删除Oracle所在目录

12、删除与Oracle有关的文件，选择Oracle所在的缺省目录C:\Oracle，删除这个入

口目录及所有子目录，并从Windows 2000目录（一般为C:\WINNT）下删除以下文

件ORACLE.INI、oradim73.INI、oradim80.INI、oraodbc.ini等等。

13、WIN.INI文件中若有[ORACLE]的标记段，删除该段

14、如有必要，删除所有Oracle相关的ODBC的DSN

15、到事件查看器中，删除Oracle相关的日志

说明：

如果有个别DLL文件无法删除的情况，则不用理会，重新启动，开始新的安装，

安装时，选择一个新的目录，则，安装完毕并重新启动后，老的目录及文件就可以删除掉了。

(t114)

在Windows NT/2000下清除Oracle8i运行环境（重新安装前的准备工作）：

1. 删除Oracle8i注册表：
regedit.exe => HKLM => Software => ORACLE

2. 删除Oracle8i服务：
regedit.exe => HKLM => System => CurrentControlset => Services=> 以Oracle开头的服务

3. 删除Oracle8i事件日志：
regedit.exe => HKLM => System => CurrentControlset => Services=> Eventlog => Application => 以Oracle开始的事件

4. 删除Windows NT/2000安装磁盘\Program Files\Oracle目录。

5. 删除Oracle8i环境变量
控制面板 => 系统 => 高级 => 环境变量
(1) 删除CLASSPATH
(2) 编辑PATH，将其中与Oracle有关系的路径删除。

6. 删除Oracle8i菜单

7. 重新启动Windows NT/2000，停止服务。

8. 删除Oracle8i主目录。

伍、Oracle数据库体系结构

Oracle数据库的体系结构包括四个方面：数据库的物理结构、逻辑结构、内存结构及进程。

　　1. 物理结构

　　物理数据库结构是由构成数据库的操作系统文件所决定，Oracle数据库文件包括：

　　数据文件（DataFile）

　　数据文件用来存储数据库中的全部数据，例如数据库表中的数据和索引数据.通常以为*.dbf格式，例如:userCIMS.dbf 。

　　日志文件（RedoLog File）

　　日志文件用于记录数据库所做的全部变更（如增加、删除、修改）、以便在系统发生故障时，用它对数据库进行恢复。名字通常为Log*.dbf格式，如：Log1CIMS.dbf,Log2CIMS.dbf 。

　　控制文件（ControlFile）

　　每个Oracle数据库都有相应的控制文件，它们是较小的二进制文件，用于记录数据库的物理结构，如：数据库名、数据库的数据文件和日志文件的名字和位置等信息。用于打开、存取数据库。名字通常为Ctrl*ctl 格式，如Ctrl1CIMS.ctl。

　　配置文件

　　配置文件记录Oracle数据库运行时的一些重要参数，如：数据块的大小，内存结构的配置等。名字通常为init*.ora 格式，如：initCIMS.ora 。

　　2 逻辑结构

　　Oracle数据库的逻辑结构描述了数据库从逻辑上如何来存储数据库中的数据。逻辑结构包括表空间、段、区、数据块和模式对象。数据库的逻辑结构将支配一个数据库如何使用系统的物理空间.模式对象及其之间的联系则描述了关系数据库之间的设计.

　　一个数据库从逻辑上说是由一个或多个表空间所组成，表空间是数据库中物理编组的数据仓库，每一个表空间是由段(segment)组成，一个段是由一组区(extent)所组成，一个区是由一组连续的数据库块(database block)组成，而一个数据库块对应硬盘上的一个或多个物理块。一个表空间存放一个或多个数据库的物理文件（即数据文件）.一个数据库中的数据被逻辑地存储在表空间上。

表空间（tablespace）

　　Oracle数据库被划分为一个或多个称为表空间的逻辑结构，它包括两类表空间，System表空间和非System表空间，其中，System表空间是安装数据库时自动建立的，它包含数据库的全部数据字典，存储过程、包、函数和触发器的定义以及系统回滚段。除此之外，还能包含用户数据。

　　一个表空间包含许多段，每个段有一些可以不连续的区组成，每个区由一组连续的数据块组成，数据块是数据库进行操作的最小单位。

　　每个表空间对应一个或多个数据文件，每个数据文件只能属于一个表空间。

　　数据库块（databaseblock）

　　数据库块也称逻辑块或ORACLE块，它对应磁盘上一个或多个物理块，它的大小由初始化参数db-block-size（在文件init.ora中）决定，典型的大小是2k。Pckfree 和pctused 两个参数用来优化数据块空间的使用。

　　区（extent）

　　区是由一组连续的数据块所组成的数据库存储空间分配的逻辑单位。

　　段（segment）

　　段是一个或多个不连续的区的集合，它包括一个表空间内特定逻辑结构的所有数据，段不能跨表空间存放。Oracle数据库包括数据段、索引段、临时段、回滚段等。

　　模式对象（schemaobject）

　　Oracle数据库的模式对象包括表、视图、序列、同意词、索引、触发器、存储.过程等，关于它们将重点在后面章节介绍。

　　3．Oracle Server系统进程与内存结构

　　当在计算机服务器上启动Oracle数据库后，称服务器上启动了一个Oracle实例（Instance）。ORACLE 实例（Instance）是存取和控制数据库的软件机制，它包含系统全局区（SGA）和ORACLE进程两部分。SGA是系统为实例分配的一组共享内存缓冲区，用于存放数据库实例和控制信息，以实现对数据库中数据的管理和操作。

进程是操作系统中一个极为重要的概念。一个进程执行一组操作，完成一个特定的任务.对ORACLE数据库管理系统来说，进程由用户进程、服务器进程和后台进程所组成。

　　当用户运行一个应用程序时，系统就为它建立一个用户进程。服务器进程处理与之相连的用户进程的请求，它与用户进程相通讯，为相连的用户进程的ORACLE请求服务。

　　为了提高系统性能，更好地实现多用户功能，ORACLE还在系统后台启动一些后台进程，用于数据库数据操作。

　　系统进程的后台进程主要包括：

　　SMON 系统监控进程：（system monitor）负责完成自动实例恢复和回收分类（sort）表空间。

　　PMON 进程监控进程：（process monitor）实现用户进程故障恢复、清理内存区和释放该进程所需资源等。

　　DBWR 数据库写进程：数据库缓冲区的管理进程。在它的管理下，数据库缓冲区中总保持有一定数量的自由缓冲块，以确保用户进程总能找到供其使用的自由缓冲块。

　　LGWR 日志文件写进程：是日志缓冲区的管理进程，负责把日志缓冲区中的日志项写入磁盘中的日志文件上。每个实例只有一个LGWR进程。

　　ARCH 归档进程：（archiver process）把已经填满的在线日志文件拷贝到一个指定的存储设备上。仅当日志文件组开关（switch）出现时，才进行ARCH操作。ARCH不是必须的，而只有当自动归档可使用或者当手工归档请求时才发出。

　　RECO 恢复进程：是在具有分布式选项时使用的一个进程，主要用于解决引用分布式事务时所出现的故障。它只能在允许分布式事务的系统中出现。

　　LCKn 封锁进程：用于并行服务器系统，主要完成实例之间的封锁。

　　内存结构（SGA）

　　SGA是Oracle为一个实例分配的一组共享内存缓冲区，它包含该实例的数据和控制信息。SGA在实例启动时被自动分配，当实例关闭时被收回。数据库的所有数据操作都要通过SGA来进行。

　　SGA中内存根据存放信息的不同，可以分为如下几个区域：

（见图 SGA中内存区域.gif）

Buffer Cache：存放数据库中数据库块的拷贝。它是由一组缓冲块所组成，这些缓冲块为所有与该实例相链接的用户进程所共享。缓冲块的数目由初始化参数DB_BLOCK_BUFFERS确定，缓冲块的大小由初始化参数DB_BLOCK_SIZE确定。大的数据块可提高查询速度。它由DBWR操作。

　　b. 日志缓冲区Redo Log Buffer：存放数据操作的更改信息。它们以日志项（redo entry）的形式存放在日志缓冲区中。当需要进行数据库恢复时，日志项用于重构或回滚对数据库所做的变更。日志缓冲区的大小由初始化参数LOG_BUFFER确定。大的日志缓冲区可减少日志文件I/O的次数。后台进程LGWR将日志缓冲区中的信息写入磁盘的日志文件中，可启动ARCH后台进程进行日志信息归档。

　　c. 共享池Shared Pool：包含用来处理的SQL语句信息。它包含共享SQL区和数据字典存储区。共享SQL区包含执行特定的SQL语句所用的信息。数据字典区用于存放数据字典，它为所有用户进程所共享。

　　Cursors：一些内存指针，执行待处理的SQL语句

　　其他信息区：除了上述几个信息区外，还包括一些进程之间的通讯信息（如封锁信息）；在多线索服务器配置下，还有一些程序全局区的信息，请求队列和响应队列等。

陆、ORACLE数据类型

字段类型中文说明限制条件其它说明

CHAR 固定长度字符串最大长度2000 bytes

VARCHAR2 可变长度的字符串最大长度4000 bytes 可做索引的最大长度749

NCHAR 根据字符集而定的固定长度字符串最大长度2000 bytes

NVARCHAR2 根据字符集而定的可变长度字符串最大长度4000 bytes

DATE 日期（日-月-年） DD-MM-YY（HH-MI-SS）经过严格测试，无千虫问题

LONG 超长字符串最大长度2G（231-1）足够存储大部头著作

RAW 固定长度的二进制数据最大长度2000 bytes 可存放多媒体图象声音等

LONG RAW 可变长度的二进制数据最大长度2G 同上

BLOB 二进制数据最大长度4G

CLOB 字符数据最大长度4G

NCLOB 根据字符集而定的字符数据最大长度4G

BFILE 存放在数据库外的二进制数据最大长度4G

ROWID 数据表中记录的唯一行号 10 bytes ********.****.****格式，*为0或1

NROWID 二进制数据表中记录的唯一行号最大长度4000 bytes

NUMBER(P,S) 数字类型 P为整数位，S为小数位

DECIMAL(P,S) 数字类型 P为整数位，S为小数位

INTEGER 整数类型小的整数

FLOAT 浮点数类型 NUMBER(38)，双精度

REAL 实数类型 NUMBER(63)，精度更高

数据类型	参数	描述
char(n)	n=1 to 2000字节	定长字符串，n字节长，如果不指定长度，缺省为1个字节长（一个汉字为2字节）
varchar2(n)	n=1 to 4000字节	可变长的字符串，具体定义时指明最大长度n，这种数据类型可以放数字、字母以及ASCII码字符集(或者EBCDIC等数据库系统接受的字符集标准)中的所有符号。如果数据长度没有达到最大值n，Oracle 8i会根据数据大小自动调节字段长度，如果你的数据前后有空格，Oracle 8i会自动将其删去。VARCHAR2是最常用的数据类型。可做索引的最大长度3209。
number(m,n)	m=1 to 38 n=-84 to 127	可变长的数值列，允许0、正值及负值，m是所有有效数字的位数，n是小数点以后的位数。如：number(5,2)，则这个字段的最大值是99,999，如果数值超出了位数限制就会被截取多余的位数。如：number(5,2)，但在一行数据中的这个字段输入575.316，则真正保存到字段中的数值是575.32。如：number(3,0)，输入575.316，真正保存的数据是575。
date	无	从公元前4712年1月1日到公元4712年12月31日的所有合法日期， Oracle 8i其实在内部是按7个字节来保存日期数据，在定义中还包括小时、分、秒。缺省格式为DD-MON-YY，如07-11月-00 表示2000年11月7日。
long	无	可变长字符列，最大长度限制是2GB，用于不需要作字符串搜索的长串数据，如果要进行字符搜索就要用varchar2类型。 long是一种较老的数据类型，将来会逐渐被BLOB、CLOB、NCLOB等大的对象数据类型所取代。
raw(n)	n=1 to 2000	可变长二进制数据，在具体定义字段的时候必须指明最大长度n，Oracle 8i用这种格式来保存较小的图形文件或带格式的文本文件，如Miceosoft Word文档。 raw是一种较老的数据类型，将来会逐渐被BLOB、CLOB、NCLOB等大的对象数据类型所取代。
long raw	无	可变长二进制数据，最大长度是2GB。Oracle 8i用这种格式来保存较大的图形文件或带格式的文本文件，如Miceosoft Word文档，以及音频、视频等非文本文件。在同一张表中不能同时有long类型和long raw类型，long raw也是一种较老的数据类型，将来会逐渐被BLOB、CLOB、NCLOB等大的对象数据类型所取代。
blob clob nclob	无	三种大型对象(LOB)，用来保存较大的图形文件或带格式的文本文件，如Miceosoft Word文档，以及音频、视频等非文本文件，最大长度是4GB。 LOB有几种类型，取决于你使用的字节的类型，Oracle 8i实实在在地将这些数据存储在数据库内部保存。可以执行读取、存储、写入等特殊操作。
bfile	无	在数据库外部保存的大型二进制对象文件，最大长度是4GB。这种外部的LOB类型，通过数据库记录变化情况，但是数据的具体保存是在数据库外部进行的。 Oracle 8i可以读取、查询BFILE，但是不能写入。大小由操作系统决定。

数据类型是列或存储过程中的一个属性。

Oracle支持的数据类型可以分为三个基本种类：字符数据类型、数字数据类型以及表示其它数据的数据类型。

字符数据类型

CHAR char数据类型存储固定长度的字符值。一个CHAR数据类型可以包括1到2000个字符。如果对CHAR没有明确地说明长度，它的默认长度则设置为1。如果对某个CHAR类型变量赋值，其长度小于规定的长度，那么Oracle自动用空格填充。

VARCHAR2 存储可变长度的字符串。虽然也必须指定一个VARCHAR2数据变量的长度，但是这个长度是指对该变量赋值的最大长度而非实际赋值长度。不需用空格填充。最多可设置为4000个字符。因为VARCHAR2数据类型只存储为该列所赋的字符（不加空格），所以VARCHAR2需要的存储空间比CHAR数据类型要小。

Oracle推荐使用VARCHAR2

NCHAR和NVARCHAR2 NCHAR和NVARCHAR2数据类型分别存储固定长度与可变长度的字符串，但是它们使用的是和数据库其他类型不同的字符集。在创建数据库时，需要指定所使用的字符集，以便对数据中数据进行编码。还可以指定一个辅助的字符集[即本地语言集]。NCHAR和NVARCHAR2类型的列使用辅助字符集。 NCHAR和NVARCHAR2类型的列使用辅助字符集。

在Oracle 9i中，可以以字符而不是字节为单位表示NCHAR和NVARCHAR2列的长度。

LONG long数据类型可以存放2GB的字符数据，它是从早期版本中继承下来的。现在如果存储大容量的数据，Oracle推荐使用CLOB和NCLOB数据类型。在表和SQL语句中使用LONG类型有许多限制。

CLOB和NCLOB CLOB和NCLOB数据类型可以存储多达4GB的字符数据。NCLOB数据类型可存储NLS数据。

数字数据类型

Oracle使用标准、可变长度的内部格式来存储数字。这个内部格式精度可以高达38位。

NUMBER数据类型可以有两个限定符，如：columnNUMBER(precision,scale)。precision表示数字中的有效位。如果没有指定precision的话，Oracle将使用38 作为精度。scale表示小数点右边的位数，scale默认设置为0。如果把scale设成负数，Oracle将把该数字取舍到小数点左边的指定位数。

日期数据类型

Oracle标准日期格式为：DD-MON-YY HH:MI:SS

通过修改实例的参数NLS_DATE_FORMAT，可以改变实例中插入日期的格式。在一个会话期间，可以通过Alter session SQL命令来修改日期，或者通过使用SQL语句的TO_DATE表达式中的参数来更新一个特定值。

其它的数据类型

RAW和LONG RAW RAW和LONG RAW数据类型主要用于对数据库进行解释。指定这两种类型时，Oracle以位的形式来存储数据。RAW数据类型一般用于存储有特定格式的对象，如位图。 RAW数据类型可占用2KB的空间，而LONG RAW数据类型则可以占用2GB大小。

ROWID ROWID是一种特殊的列类型，称之为伪列（pseudocolumn）。ROWID伪列在SQL SELECT语句中可以像普通列那样被访问。Oracle数据库中每行都有一个伪列。ROWID表示行的地址，ROWID伪列用ROWID数据类型定义。

ROWID与磁盘驱动的特定位置有关，因此，ROWID是获得行的最快方法。但是，行的ROWID会随着卸载和重载数据库而发生变化，因此建议不要在事务中使用ROWID伪列的值。例如，一旦当前应用已经使用完记录，就没有理由保存行的ROWID。不能通过任何SQL语句来设置标准的ROWID伪列的值。

列或变量可以定义成ROWID数据类型，但是Oracle不能保证该列或变量的值是一个有效的ROWID。

LOB（大型对象）数据类型，可以保存4GB的信息。LOB有以下3中类型：

，只能存储字符数据

，保存本地语言字符集数据

，以二进制信息保存数据

可以指定将一个LOB数据保存在Oracle数据库内，还是指向一个包含次数据的外部文件。

LOB可以参与事务。管理LOB中的数据必须通过DBMS_LOB PL/SQL内置软件包或者OGI接口。

为了便于将LONG数据类型转换成LOB，Oracle 9i包含许多同时支持LOB和LONG的函数，喊包括一个ALTER TABLE语句的新选择，它允许将LONG数据类型自动转换成LOB。

BFILE

BFILE数据类型用做指向存储在Oracle数据库以外的文件的指针。

XML Type

作为对XML支持的一部分，Oracle9i包含了一个新的数据类型XML Type。定义为XMLType的列将存储一个字符LOB列中的XML文档。有许多内置的功能可以使你从文档中抽取单个节点，还可以在XML Type文档中对任何节点创建索引。

用户自定义数据

从Oracle 8以后，用户可以定义自己的复杂数据类型，它们由Oracle基本数据类型组合而成。

AnyType、AnyData和AnyDataSet

Oracle包括3个新的数据类型，用于定义在现有数据类型之外的数据结构。其中每种数据类型必须用程序单元来定义，以便让Oracle9i知道如何处理这些类型的特定实现。

类型转换

Oracle会自动将某些数据类型转换成其他的数据类型，转换取决于包括该值的SQL语句。

数据转换还可以通过Oracle的类型转换函数显示地进行。

连接与比较

在大多数平台上Oracle SQL中的连接操作符用两条竖线（||）表示。连接是将两个字符值连接。Oracle的自动类型转换功能使得两个数字值也可以进行连接。

NULL

NULL值是关系数据库的重要特征之一。实际上，NULL不代表任何值，它表示没有值。如果要创建表的一个列，而这个列必须有值，那么应将它指定为NOT NULL，这表示该列不能包含NULL值。

任何数据类型都可以赋予NULL值。NULL值引入了SQL运算的三态逻辑。如果比较的一方是NULL值，那么会出现3种状态：TURE、FALSE以及两者都不是。

因为NULL值不等于0或其他任何值，所以测试某个数据是否为NULL值只能通过关系运算符IS NULL来进行。

NULL值特别适合以下情况：当一个列还未赋值时。如果选择不使用NULL值，那么必须对行的所有列都要赋值。这实际上也取消了某列不需要值的可能性，同时对它赋的值也很容易产生误解。这种情况则可能误导终端用户，并且导致累计操作的错误结果。

number(p,s)

p:1~38

s:-84~127

p>0，对s分2种情况：1. s>0

精确到小数点右边s位，并四舍五入。然后检验有效数位是否<=p；如果s>p，小数点右边至少有s-p个0填充。

2. s<0

精确到小数点左边s位，并四舍五入。然后检验有效数位是否<=p+|s|

123.2564 NUMBER 123.2564

1234.9876 NUMBER(6,2) 1234.99

12345.12345 NUMBER(6,2) Error

1234.9876 NUMBER(6) 1235

12345.345 NUMBER(5,-2) 12300

1234567 NUMBER(5,-2) 1234600

12345678 NUMBER(5,-2) Error

123456789 NUMBER(5,-4) 123460000

1234567890 NUMBER(5,-4) Error

12345.58 NUMBER(*, 1) 12345.6

0.1 NUMBER(4,5) Error

0.01234567 NUMBER(4,5) 0.01235

0.09999 NUMBER(4,5) 0.09999

oracle 的命名规则：
1、要以字母开头
2、包含字母和数字，以及# $
3、不能超过30个字符

oracle基本数据类型

数据类型	参数	描述
char(n)	n=1 to 2000字节	定长字符串，n字节长，如果不指定长度，缺省为1个字节长（一个汉字为2字节）
varchar2(n)	n=1 to 4000字节	可变长的字符串，具体定义时指明最大长度n，这种数据类型可以放数字、字母以及ASCII码字符集(或者EBCDIC等数据库系统接受的字符集标准)中的所有符号。如果数据长度没有达到最大值n，Oracle 8i会根据数据大小自动调节字段长度，如果你的数据前后有空格，Oracle 8i会自动将其删去。VARCHAR2是最常用的数据类型。可做索引的最大长度3209。
number(m,n)	m=1 to 38 n=-84 to 127	可变长的数值列，允许0、正值及负值，m是所有有效数字的位数，n是小数点以后的位数。如：number(5,2)，则这个字段的最大值是99,999，如果数值超出了位数限制就会被截取多余的位数。如：number(5,2)，但在一行数据中的这个字段输入575.316，则真正保存到字段中的数值是575.32。如：number(3,0)，输入575.316，真正保存的数据是575。
date	无	从公元前4712年1月1日到公元4712年12月31日的所有合法日期， Oracle 8i其实在内部是按7个字节来保存日期数据，在定义中还包括小时、分、秒。缺省格式为DD-MON-YY，如07-11月-00 表示2000年11月7日。
long	无	可变长字符列，最大长度限制是2GB，用于不需要作字符串搜索的长串数据，如果要进行字符搜索就要用varchar2类型。 long是一种较老的数据类型，将来会逐渐被BLOB、CLOB、NCLOB等大的对象数据类型所取代。
raw(n)	n=1 to 2000	可变长二进制数据，在具体定义字段的时候必须指明最大长度n，Oracle 8i用这种格式来保存较小的图形文件或带格式的文本文件，如Miceosoft Word文档。 raw是一种较老的数据类型，将来会逐渐被BLOB、CLOB、NCLOB等大的对象数据类型所取代。
long raw	无	可变长二进制数据，最大长度是2GB。Oracle 8i用这种格式来保存较大的图形文件或带格式的文本文件，如Miceosoft Word文档，以及音频、视频等非文本文件。在同一张表中不能同时有long类型和long raw类型，long raw也是一种较老的数据类型，将来会逐渐被BLOB、CLOB、NCLOB等大的对象数据类型所取代。
blob clob nclob	无	三种大型对象(LOB)，用来保存较大的图形文件或带格式的文本文件，如Miceosoft Word文档，以及音频、视频等非文本文件，最大长度是4GB。 LOB有几种类型，取决于你使用的字节的类型，Oracle 8i实实在在地将这些数据存储在数据库内部保存。可以执行读取、存储、写入等特殊操作。
bfile	无	在数据库外部保存的大型二进制对象文件，最大长度是4GB。这种外部的LOB类型，通过数据库记录变化情况，但是数据的具体保存是在数据库外部进行的。 Oracle 8i可以读取、查询BFILE，但是不能写入。大小由操作系统决定。

oracle 数据库中讨论char ,varchar ,varchar2 数据类型!

这3种字符串数据类型是我们使用最多的，我们在数据库设计时到底该怎么使用了？

首先我们先来分析3个数据类型的说明：

1。char

CHAR的长度是固定的,最长2000个字符。

2。varchar 和 varchar2

可以肯定的是oracle中目前是可以使用varchar数据类型的，但他们的区别我查了不少资料也没有找到一个准确的答案最常见的说话是说oracle中的varchar只是varchar2的别名也就是同义词。

其次也有人认为varchar是最大长度为2000的可变字符串（和sql server中的varchar一致），而varchar2最大长度为4000。

知道了他们的特点我们就来讨论下使用区别

1.char和varchar、varchar2

由于varchar和varchar2用途类似，我们先来讨论char和他们的使用区别：

varchar和varchar2比char节省空间，在效率上比char会稍微差一些，即要想获得效率，就必须牺牲一定的空间，这也就是我们在数据库设计上常说的‘以空间换效率’。

　　varchar和varchar2虽然比char节省空间，但是如果一个varchar和varchar2列经常被修改，而且每次被修改的数据的长度不同，这会引起‘行迁移’(Row Migration)现象，而这造成多余的I/O，是数据库设计和调整中要尽力避免的，在这种情况下用char代替varchar和varchar2会更好一些。

当然还有一种情况就是象身份证这种长度几乎不变的字段可以考虑使用char，以获得更高的效率。

2。varchar和varchar2

这里就进入重点了，前面的区别我们在sql server中我们已经基本了解了，大家可能都知道，最多也就是复习下，但oracle增加了一个varchar2类型，是大家以前所没有用到过的。

因为oracle保证在任何版本中该数据类型向上和向下兼容，但不保证varchar，还有其他数据中一般都有varchar这个数据类型。

所以我得出了以下结论：

如果想在oracle新版本的数据库兼容就不要用varchar,如果想和oracle之外其他数据库兼容就不要用varchar2。

ORACLE中的数据类型分类

ORACLE中的数据类型不可谓不多，下面把我这两天来的学习体会写一下吧！1、字符数据类型：包括我CHAR，VARCHAR2，LONG。CHAR型可以存储字母数字值，这种数据类型的列长度可以是1到2000个字节。如果未指明，则默认其占用一个字节，如果用户输入的值小于指定的长度，数据库则用空格填充至固定长度。VARCHAR2型其实就是VARCHAR，只不过后面多了一个数字2，VARCHAR2就是VARCHAR的同义词，也称别名。数据类型大小在1至4000个字节，但是和 CHAR不同的一点是：当你定义了VARCHAR2长度为30，但是你只输入了10个字符，这时VARCHAR2不会像CHAR一样填充，在数据库中只有 10具字节。 LONG型：此数据类型用来存储可变长度的字符数据，最多能存储2GB。但是有一些限制：一个表中只有一列可以为LONG型，LONG列不能定义为主键或唯一约束，不能建立索引，过程或存储过程不能接受LONG数据类型的参数。 2、数值数据类型只有NUMBER型，但是NUMBER功能不小，它可以存储正数，负数，零，定点数和精度为30位的浮点数。格式为（P=38，S=0），其中P为精度，表示数字的总位数，它在1-38之间，S为范围，表示小数点右边的数字的位数，它在-84至127之间。 3、日期时间数据类型：有DATE数据类型，TIMESTAMP数据类型。DATE用于存储表中的日期和时间数据，ORACLE使用自己的格式存储日期，使用7个字节固定长度，每个字节分别存储世纪，年月日，小时，分和秒。日期数据类型的值从公元前4712年1月1日到公元9999年12月31日。ORACLE中的SYSDATE函数用于返回当前的日期和时间。TIMESTAMP数据类型与DATE不同的是：它还返回当前的时区。 4RAW和LONG RAW 数据类型此种数据类型主要用于存储二进制数据。 RAW用于存储基于字节的数据，最多能存储2000个字节，它没有默认大小，所以在使用时要指定大小，可以建立索引。 RAW LONG用于存储可变长度的二进制数据，最多能存储2GB，它受的限制和LONG类型一样。 5、LOB数据类型 LOB又称为“大对象”数据类型：主要有CLOB，BLOB，BFILE，三种子类型。 CLOB代表（CHARACTERLOB），它能够存储大量字符数据，可以存储非结构化的XML文档。 BLOG代表（BINARY LOB），它可以存储较大的二进制对象；如图形，音视频剪辑。 BFILE 代表（BINARY FILE），它能够将二进制文件存储在数据库外部的操作系统文件中，注意是二进制文件，不是一般数据，BFILE列存储一个BFILE定位器，它指向位于服务器文件系统上的二进制文件，支持的文件最大为4GB。不过ORACLE10以上的会更大，这还需要硬件方面的支持。

Oracle数据类型总结比较全(备注转载)

一 varchar,nvarchar,
四个类型都属于变长字符类型， varchar和varchar2的区别在与后者把所有字符都占两字节，前者只对汉字和全角等字符占两字节。 nvarchar和nvarchar2的区别和上面一样，   与上面区别在于是根据Unicode   标准所进行的定义的类型，通常用于支持多国语言类似系统的定义。

1.char

char的长度是固定的，比如说，你定义了char(20),即使你你插入abc，不足二十个字节，数据库也会在abc后面自动加上17个空格，以补足二十个字节；

char是区分中英文的，中文在char中占两个字节，而英文占一个，所以char(20)你只能存20个字母或10个汉字。

char适用于长度比较固定的，一般不含中文的情况

2.varchar/varchar2

varchar是长度不固定的，比如说，你定义了varchar(20),当你插入abc，则在数据库中只占3个字节。

varchar同样区分中英文，这点同char。

varchar2基本上等同于varchar，它是oracle自己定义的一个非工业标准varchar，不同在于，varchar2用null代替varchar的空字符串

varchar/varchar2适用于长度不固定的，一般不含中文的情况

3.nvarchar/nvarchar2

nvarchar和nvarchar2是长度不固定的

nvarchar不区分中英文，比如说：你定义了nvarchar(20),你可以存入20个英文字母/汉字或中英文组合，这个20定义的是字符数而不是字节数

nvarchar2基本上等同于nvarchar，不同在于nvarchar2中存的英文字母也占两个字节

nvarchar/nvarchar2适用于存放中文

char [ ( n ) ]

    固定长度，非 Unicode 字符数据，长度为 n 个字节。n 的取值范围为 1 至 8,000，存储大小是 n 个字节。

varchar [ ( n | max ) ]

    可变长度，非 Unicode 字符数据。n 的取值范围为 1 至 8,000。max 指示最大存储大小是 2^31-1 个字节。存储大小是输入数据的实际长度加 2 个字节，用于反映存储的数据的长度。所输入数据的长度可以为 0 个字符。

    * 如果列数据项的大小一致，则使用 char。
    * 如果列数据项的大小差异相当大，则使用 varchar。
    * 如果列数据项大小相差很大，而且大小可能超过 8,000 字节，请使用 varchar(max)。

如果未在数据定义或变量声明语句中char 或 varchar 数据类型指定 n，则默认长度为 1。如果在使用CAST 和 CONVERT 函数时char 或 varchar 数据类型未指定 n，则默认长度为 30。
当执行 CREATE TABLE 或 ALTER TABLE 时，如果 SET ANSI_PADDING 为 OFF，则定义为 NULL 的 char 列将作为varchar 处理。
另外帮助理解的，只供参考：转自http://www.51testing.com/?uid-258885-action-viewspace-itemid-141197
也可参照学习http://ce.sysu.edu.cn/garden/dispbbs.asp?boardid=26&ID=8774&replyID=18180&skin=1
1.NULL值(空值)。

     a. char列的NULL值占用存储空间。

     b. varcahr列的NULL值不占用存储空间。

     c. 插入同样数量的NULL值，varchar列的插入效率明显高出char列。
2.插入数据

    无论插入数据涉及的列是否建立索引，char的效率都明显低于varchar。

3. 更新数据

     如果更新的列上未建立索引，则char的效率低于varchar，差异不大；建立索引的话，效率较高。

4. 修改结构

     a. 无论增加或是删除的列的类型是char还是varchar，操作都能较快的完成，而且效率上没有什么差异。

     b. 对于增加列的宽度而言，char与varchar有非常明显的效率差异，修改varcahr列基本上不花费时间，而修改char列需要花费很长的时间。

5.数据检索

     无论是否通过索引，varchar类型的数据检索略优于char的扫描。

选择char还是选择varchar的建议

    1.适宜于char的情况：

     a. 列中的各行数据长度基本一致，长度变化不超过50字节；

     b. 数据变更频繁，数据检索的需求较少。

     c. 列的长度不会变化，修改char类型列的宽度的代价比较大。

     d. 列中不会出现大量的NULL值。

     e. 列上不需要建立过多的索引，过多的索引对char列的数据变更影响较大。

    2.适宜于varchar的情况;

     a. 列中的各行数据的长度差异比较大。

     b. 列中数据的更新非常少，但查询非常频繁。
     c. 列中经常没有数据，为NULL值或为空值

nchar [ ( n ) ]

    n 个字符的固定长度的 Unicode 字符数据。n 值必须在 1 到 4,000 之间（含）。存储大小为两倍 n 字节。

nvarchar [ ( n | max ) ]

    可变长度 Unicode 字符数据。n 值在 1 到 4,000 之间（含）。max 指示最大存储大小为 2^31-1 字节。存储大小是所输入字符个数的两倍 + 2 个字节。所输入数据的长度可以为 0 个字符。

注释

如果没有在数据定义或变量声明语句中指定 n，则默认长度为 1。如果没有使用 CAST 函数指定 n，则默认长度为30。

如果列数据项的大小可能相同，请使用 nchar。

如果列数据项的大小可能差异很大，请使用 nvarchar。

sysname 是系统提供的用户定义数据类型，除了不可为空值外，在功能上与 nvarchar(128) 相同。sysname 用于引用数据库对象名。

为使用 nchar 或 nvarchar 的对象分配的是默认的数据库排序规则，但可使用 COLLATE 子句分配特定的排序规则。

SET ANSI_PADDING ON 永远适用于 nchar 和 nvarchar。SET ANSI_PADDING OFF 不适用于 nchar 或 nvarchar 数据类型。

在Oracle中CHAR,NCHAR,VARCHAR,VARCHAR2,NVARCHAR2这五种类型的区别

1.CHAR(size)和VARCHAR(size)的区别
    CHAR为定长的字段，最大长度为2K字节；
    VARCHAR为可变长的字段，最大长度为4K字节；

2.CHAR(size)和NCHAR(size)的区别
    CHAR如果存放字母数字占1个字节，存放GBK编码的汉字存放2个字节，存放UTF-8编码的汉字占用3个字节；
    NCHAR根据所选字符集来定义存放字符的占用字节数，一般都为2个字节存放一个字符(不管字符或者汉字)

3.VARCHAR(size)和VARCHAR2(size)的区别
    在现在的版本中，两者是没有区别的；最大长度为4K字节；推荐使用VARCHAR2；

4.VARCHAR2(size)和NVARCHAR2(size)的区别
    最大长度为4K字节，区别同CHAR与NCHAR的区别；（如果数据库字符集长度是2，则NVARCHAR2最大为2K）

5.共同特性
    当执行insert的时候，插入的值为''，则转变成null，即insert... values('') <=> insert ... values(null)
    搜索的条件须用where xx is null

6.例子
    比如有一个性别字段，里面存放“男，女”的其中一个值，两种常用选择
        CHAR(2)    和 NCHAR(1)

柒、c#通过oledb连接Oracle

先装oracle客户端

1、控制面板->管理工具->数据源(ODBC)->添加数据源->选择oracle 客户端

Data Source Name 可以任意起名，推荐和SID一样

Description 描述

TNS Service Name 下拉菜单中会自动显示环境变量TNS_ADMIN所指目录下的tnsnames.ora文件中SERVICE_NAME的名称，也就是要连接的SID UserID 用户名

2、代码

string ConnectionString = "DataSource=orcl; User Id=SCOTT; Password=scott"; //连接字符串

OracleConnection conn = newOracleConnection(ConnectionString); //创建一个新连接

try

{

conn.Open(); //打开连接

OracleCommand cmd = conn.CreateCommand();

cmd.CommandText = "select * fromemp"; //SQL语句

OracleDataReader rs = cmd.ExecuteReader();

while (rs.Read()) //读取数据，如果rs.Read()返回为false的话，就说明到记录集的尾部了

{

MessageBox.Show(rs.GetString(1));

}

rs.Close();

}

catch (Exception e)

{

MessageBox.Show(e.Message);

}

finally

{

conn.Close();

}

Oracle

ODBC

New version:

"Driver={Microsoft ODBC forOracle};Server=OracleServer.world;Uid=Username;Pwd=asdasd;"

Old version:

"Driver={Microsoft ODBC Driver forOracle};ConnectString=OracleServer.world;Uid=myUsername;Pwd=myPassword;"

OLEDB, OleDbConnection (.NET)

Standard security:

"Provider=msdaora;DataSource=MyOracleDB;User Id=UserName;Password=asdasd;"

This one's from Microsoft, the followingare from Oracle

Standard Security:

"Provider=OraOLEDB.Oracle;DataSource=MyOracleDB;User Id=Username;Password=asdasd;"

Trusted Connection:

"Provider=OraOLEDB.Oracle;DataSource=MyOracleDB;OSAuthent=1;"

OracleConnection (.NET)

Standard:

"Data Source=Oracle8i;IntegratedSecurity=yes";

This one works only with Oracle 8i release3 or later

Declare the OracleConnection:

C#:

using System.Data.OracleClient;

OracleConnection oOracleConn = newOracleConnection();

oOracleConn.ConnectionString = "myconnectionstring";

oOracleConn.Open();

VB.NET:

Imports System.Data.OracleClient

Dim oOracleConn As OracleConnection = NewOracleConnection()

oOracleConn.ConnectionString = "myconnectionstring"

oOracleConn.Open()

Data Shape

MS Data Shape:

"Provider=MSDataShape.1;PersistSecurity Info=False;Data Provider=MSDAORA;Data Source=orac;userid=username;password=mypw"

捌、一个C#操作Oracle的通用类

using System;

using System.Data;

using System.Data.OracleClient;

using System.Web.UI.WebControls;

namespace SiFenManager.Util

{

///

/// 数据库通用操作类

///

public class Database

{

protected OracleConnection con;//连接对象

public Database()

{

con=newOracleConnection(DafangFramework.AppConfig.DataBaseConnectionString);

}

public Database(string constr)

{

con=new OracleConnection(constr);

}

#region 打开数据库连接

///

/// 打开数据库连接

///

private void Open()

{

//打开数据库连接

if(con.State==ConnectionState.Closed)

{

try

{

//打开数据库连接

con.Open();

}

catch(Exception e)

{

throw e;

}

#endregion

#region 关闭数据库连接

///

/// 关闭数据库连接

///

private void Close()

{

//判断连接的状态是否已经打开

if(con.State==ConnectionState.Open)

{

con.Close();

}

#endregion

#region 执行查询语句，返回OracleDataReader ( 注意：调用该方法后，一定要对OracleDataReader进行Close )

///

/// 执行查询语句，返回OracleDataReader ( 注意：调用该方法后，一定要对OracleDataReader进行Close )

///

/// 查询语句

/// OracleDataReader

public OracleDataReaderExecuteReader(string sql)

{

OracleDataReader myReader;

Open();

OracleCommand cmd = new OracleCommand(sql,con);

myReader =cmd.ExecuteReader(CommandBehavior.CloseConnection);

return myReader;

}

#endregion

#region 执行带参数的SQL语句

///

/// 执行SQL语句，返回影响的记录数

///

/// SQL语句

/// 影响的记录数

public int ExecuteSql(string sql,params OracleParameter[] cmdParms)

{

OracleCommand cmd = new OracleCommand();

{

try

{

PrepareCommand(cmd, con, null, sql,cmdParms);

int rows = cmd.ExecuteNonQuery();

cmd.Parameters.Clear();

return rows;

}

catch(System.Data.OracleClient.OracleException e)

{

throw e;

}

#endregion

#region 执行带参数的SQL语句

///

/// 执行不带参数的SQL语句

///

/// SQL语句

public void ExecuteSql(stringsql)

{

OracleCommand cmd = newOracleCommand(sql,con);

try

{

Open();

cmd.ExecuteNonQuery();

Close();

}

catch(System.Data.OracleClient.OracleException e)

{

Close();

throw e;

}

#endregion

#region 执行SQL语句，返回数据到DataSet中

///

/// 执行SQL语句，返回数据到DataSet中

///

/// sql语句

/// 返回DataSet

public DataSet GetDataSet(stringsql)

{

DataSet ds=new DataSet();

try

{

Open();//打开数据连接

OracleDataAdapter adapter=new OracleDataAdapter(sql,con);

adapter.Fill(ds);

}

catch//(Exception ex)

{

}

finally

{

Close();//关闭数据库连接

}

return ds;

}

#endregion

#region 执行SQL语句，返回数据到自定义DataSet中

///

/// 执行SQL语句，返回数据到DataSet中

///

/// sql语句

/// 自定义返回的DataSet表名

/// 返回DataSet

public DataSet GetDataSet(stringsql,string DataSetName)

{

DataSet ds=new DataSet();

Open();//打开数据连接

OracleDataAdapter adapter=new OracleDataAdapter(sql,con);

adapter.Fill(ds,DataSetName);

Close();//关闭数据库连接

return ds;

}

#endregion

#region 执行Sql语句,返回带分页功能的自定义dataset

///

/// 执行Sql语句,返回带分页功能的自定义dataset

///

/// Sql语句

/// 每页显示记录数

/// 当前页

/// 返回dataset表名

/// 返回DataSet

public DataSet GetDataSet(stringsql,int PageSize,int CurrPageIndex,string DataSetName)

{

DataSet ds=new DataSet();

Open();//打开数据连接

OracleDataAdapter adapter=new OracleDataAdapter(sql,con);

adapter.Fill(ds,PageSize * (CurrPageIndex -1), PageSize,DataSetName);

Close();//关闭数据库连接

return ds;

}

#endregion

#region 执行SQL语句，返回记录总数

///

/// 执行SQL语句，返回记录总数

///

/// sql语句

/// 返回记录总条数

public int GetRecordCount(stringsql)

{

int recordCount = 0;

Open();//打开数据连接

OracleCommand command = new OracleCommand(sql,con);

OracleDataReader dataReader =command.ExecuteReader();

while(dataReader.Read())

{

recordCount++;

}

dataReader.Close();

Close();//关闭数据库连接

return recordCount;

}

#endregion

#region 统计某表记录总数

///

/// 统计某表记录总数

///

/// 主键/索引键

/// 数据库.用户名.表名

/// 查询条件

/// 返回记录总数

public int GetRecordCount(stringkeyField, string tableName, string condition)

{

int RecordCount = 0;

string sql = "select count(" + keyField+ ") as count from " + tableName + " " + condition;

DataSet ds = GetDataSet(sql);

if (ds.Tables[0].Rows.Count > 0)

{

RecordCount=Convert.ToInt32(ds.Tables[0].Rows[0][0]);

}

ds.Clear();

ds.Dispose();

return RecordCount;

}

///

/// 统计某表记录总数

///

/// 可重复的字段

/// 数据库.用户名.表名

/// 查询条件

/// 字段是否主键

/// 返回记录总数

public int GetRecordCount(stringField, string tableName, string condition, bool flag)

{

int RecordCount = 0;

if (flag)

{

RecordCount = GetRecordCount(Field,tableName, condition);

}

else

{

string sql = "selectcount(distinct(" + Field + ")) as count from " + tableName +" " + condition;

DataSet ds = GetDataSet(sql);

if (ds.Tables[0].Rows.Count > 0)

{

RecordCount =Convert.ToInt32(ds.Tables[0].Rows[0][0]);

}

ds.Clear();

ds.Dispose();

}

return RecordCount;

}

#endregion

#region 统计某表分页总数

///

/// 统计某表分页总数

///

/// 主键/索引键

/// 表名

/// 查询条件

/// 页宽

/// 记录总数

/// 返回分页总数

public int GetPageCount(stringkeyField, string tableName, string condition, int pageSize, int RecordCount)

{

int PageCount = 0;

PageCount = (RecordCount % pageSize) > 0? (RecordCount / pageSize) + 1 : RecordCount / pageSize;

if (PageCount < 1) PageCount = 1;

return PageCount;

}

///

/// 统计某表分页总数

///

/// 主键/索引键

/// 表名

/// 查询条件

/// 页宽

/// 返回页面总数

public int GetPageCount(stringkeyField, string tableName, string condition, int pageSize, ref intRecordCount)

{

RecordCount = GetRecordCount(keyField,tableName, condition);

return GetPageCount(keyField, tableName, condition,pageSize, RecordCount);

}

///

/// 统计某表分页总数

///

/// 可重复的字段

/// 表名

/// 查询条件

/// 页宽

/// 是否主键

/// 返回页页总数

public int GetPageCount(stringField, string tableName, string condition, ref int RecordCount, int pageSize,bool flag)

{

RecordCount = GetRecordCount(Field,tableName, condition, flag);

return GetPageCount(Field, tableName,condition, pageSize, ref RecordCount);

}

#endregion

#region Sql分页函数

///

/// 构造分页查询SQL语句

///

/// 主键

/// 所有需要查询的字段(field1,field2...)

/// 库名.拥有者.表名

/// 查询条件1(where ...)

/// 排序条件2(order by ...)

/// 当前页号

/// 页宽

/// SQL语句

public string JoinPageSQL(stringKeyField, string FieldStr, string TableName, string Where, string Order, intCurrentPage, int PageSize)

{

string sql = null;

if (CurrentPage == 1)

{

sql = "select " + CurrentPage * PageSize + "" + FieldStr + " from " + TableName + " " + Where +" " + Order + " ";

}

else

{

sql = "select * from (";

sql += "select " + CurrentPage * PageSize + "" + FieldStr + " from " + TableName + " " + Where +" " + Order + ") a ";

sql += "where " + KeyField +" not in (";

sql += "select " + (CurrentPage - 1) * PageSize +" " + KeyField + " from " + TableName + " " +Where + " " + Order + ")";

}

return sql;

}

///

/// 构造分页查询SQL语句

///

/// 字段名(非主键)

/// 库名.拥有者.表名

/// 查询条件1(where ...)

/// 排序条件2(order by ...)

/// 当前页号

/// 页宽

/// SQL语句

public string JoinPageSQL(stringField, string TableName,string Where, string Order, int CurrentPage, intPageSize)

{

string sql = null;

if (CurrentPage == 1)

{

sql = "select rownum " +CurrentPage * PageSize + " " + Field + " from " + TableName+ " " + Where + " " + Order + " group by " +Field;

}

else

{

sql = "select * from (";

sql += "select rownum " +CurrentPage * PageSize + " " + Field + " from " + TableName+ " " + Where + " " + Order + " group by " +Field + " ) a ";

sql += "where " + Field + "not in (";

sql += "select rownum " +(CurrentPage - 1) * PageSize + " " + Field + " from " +TableName + " " + Where + " " + Order + " group by" + Field + ")";

}

return sql;

}

#endregion

#region 根据系统时间动态生成各种查询语句(现已经注释掉，以备以后使用)

// #region 根据查询时间的条件，动态生成查询语句

// ///

// /// 根据查询时间的条件，动态生成查询语句

// ///

// /// 开始时间

// /// 结束时间

// /// 单位

// /// 开始线损率

// /// 结束线损率

// /// 单位字段

// /// 线损率字段

// /// 表后缀

// /// SQL语句

// public string SQL(DateTimestarttime,DateTime endtime,string dw,float startxsl,float endxsl,stringdanwei,string xiansunlv,string tablehz)

// {

// string sql=null;

// //将输入的时间格式转换成固定的格式"yyyy-mm-dd"

// string zstarttime=starttime.GetDateTimeFormats('D')[1].ToString();

// string zendtime=endtime.GetDateTimeFormats('D')[1].ToString();

// string nTime=DateTime.Now.GetDateTimeFormats('D')[1].ToString();

// //取日期值的前六位，及年月值

// string sTime=zstarttime.Substring(0,4)+zstarttime.Substring(5,2);

// string eTime=zendtime.Substring(0,4)+zendtime.Substring(5,2);

// string nowTime=nTime.Substring(0,4)+nTime.Substring(5,2);

// //分别取日期的年和月

// int sy=Convert.ToInt32(zstarttime.Substring(0,4));

// int ey=Convert.ToInt32(zendtime.Substring(0,4));

// int sm=Convert.ToInt32(zstarttime.Substring(5,2));

// int em=Convert.ToInt32(zendtime.Substring(5,2));

// //相关变量定义

// int s;

// int e;

// int i;

// int j;

// int js;

// int nz;

// string x;

// //一，取当前表生成SQL语句

// if(sTime==nowTime&&eTime==nowTime)

// {

// sql="select * from"+tablehz+" "+"where"+""+danwei+"="+dw+" "+""+"and"+" "+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+"";

// }

// //二，取当前表和其他表生成SQL语句

// else if(sTime==nowTime&&eTime!=nowTime)

// {

// sql="select * from"+tablehz+" "+"where"+""+danwei+"="+dw+" "+""+"and"+" "+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// //如果年份相等

// if(sy==ey)

// {

// s=Convert.ToInt32(sTime);

// e=Convert.ToInt32(eTime);

// for(i=s+1;i

// {

// i=i++;

// sql+="select * from"+i.ToString()+'_'+tablehz+" "+"where"+""+danwei+"="+dw+" "+""+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// sql+="select * from"+e.ToString()+'_'+tablehz+" "+"where"+""+danwei+"="+dw+" "+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+"";

// }

// //结束年份大于开始年份

// else

// {

// //1，先循环到起始时间和起始时间的12月

// s=Convert.ToInt32(sTime);

// x=zstarttime.Substring(0,4)+"12";

// nz=Convert.ToInt32(x);

// for(i=s+1;i<=nz;i++)

// {

// i=i++;

// sql+="select * from "+i.ToString()+'_'+tablehz+""+"where"+" "+danwei+"="+dw+""+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// //2，循环两者相差年份

// for(i=sy+1;i

// {

// for(j=1;j<=12;j++)

// {

// if(j<10)

// {

// sql+="select * from"+i.ToString()+"0"+j.ToString()+'_'+tablehz+""+"where"+" "+danwei+"="+dw+" "+""+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// else

// {

// sql+="select * from"+i.ToString()+j.ToString()+'_'+tablehz+""+"where"+" "+danwei+"="+dw+""+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// //3，循环到结束的月份

// js=Convert.ToInt32(zendtime.Substring(0,4)+"00");

// for(i=js;i

// {

// i++;

// sql+="select * from"+i.ToString()+'_'+tablehz+" "+"where"+""+danwei+"="+dw+" "+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// sql+="select * from"+eTime.ToString()+'_'+tablehz+" "+"where"+""+danwei+"="+dw+" "+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+"";

// }

// //三，取其他表生成生成SQL语句

// else

// {

// //1，先循环到起始时间和起始时间的12月

// s=Convert.ToInt32(sTime);

// x=zstarttime.Substring(0,4)+"12";

// nz=Convert.ToInt32(x);

// for(i=s;i<=nz;i++)

// {

// i=i++;

// sql+="select * from"+i.ToString()+'_'+tablehz+" "+"where"+""+danwei+"="+dw+" "+""+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// //2，循环两者相差年份

// for(i=sy+1;i

// {

// for(j=1;j<=12;j++)

// {

// if(j<10)

// {

// sql+="select * from"+i.ToString()+"0"+j.ToString()+'_'+tablehz+""+"where"+" "+danwei+"="+dw+" "+""+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// else

// {

// sql+="select * from"+i.ToString()+j.ToString()+'_'+tablehz+""+"where"+" "+danwei+"="+dw+""+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// //3，循环到结束的月份

// js=Convert.ToInt32(zendtime.Substring(0,4)+"00");

// for(i=js;i

// {

// i++;

// sql+="select * from"+i.ToString()+'_'+tablehz+" "+"where"+""+danwei+"="+dw+" "+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// sql+="select * from"+eTime.ToString()+'_'+tablehz+" "+"where"+""+danwei+"="+dw+" "+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+"";

// }

// return sql;

// }

// #endregion

// #region 根据查询时间的条件，动态生成查询语句

// ///

// /// 根据查询时间的条件，动态生成查询语句

// ///

// /// 开始时间

// /// 结束时间

// /// 查询字段

// /// 查询条件

// /// 表后缀

// /// SQL语句

// public string SQL(DateTimestarttime,DateTime endtime,string zhiduan,string tiaojiao,string tablehz)

// {

// string sql=null;

// //将输入的时间格式转换成固定的格式"yyyy-mm-dd"

// string zstarttime=starttime.GetDateTimeFormats('D')[1].ToString();

// string zendtime=endtime.GetDateTimeFormats('D')[1].ToString();

// string nTime=DateTime.Now.GetDateTimeFormats('D')[1].ToString();

// //取日期值的前六位，及年月值

// string sTime=zstarttime.Substring(0,4)+zstarttime.Substring(5,2);

// string eTime=zendtime.Substring(0,4)+zendtime.Substring(5,2);

// string nowTime=nTime.Substring(0,4)+nTime.Substring(5,2);

// //分别取日期的年和月

// int sy=Convert.ToInt32(zstarttime.Substring(0,4));

// int ey=Convert.ToInt32(zendtime.Substring(0,4));

// int sm=Convert.ToInt32(zstarttime.Substring(5,2));

// int em=Convert.ToInt32(zendtime.Substring(5,2));

// //相关变量定义

// int s;

// int e;

// int i;

// int j;

// int js;

// int nz;

// string x;

// //一，取当前表生成SQL语句

// if(sTime==nowTime&&eTime==nowTime)

// {

// sql="select"+" "+zhiduan+""+"from"+" "+tablehz+""+"where"+" "+tiaojiao+" ";

// }

// //二，取当前表和其他表生成SQL语句

// else if(sTime==nowTime&&eTime!=nowTime)

// {

// sql="select"+" "+zhiduan+""+"from"+" "+tablehz+""+"where"+" "+tiaojiao+""+"union"+" ";

// //如果年份相等

// if(sy==ey)

// {

// s=Convert.ToInt32(sTime);

// e=Convert.ToInt32(eTime);

// for(i=s+1;i

// {

// i=i++;

// sql+="select"+" "+zhiduan+""+"from"+" "+i.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+""+"union"+" ";

// }

// sql+="select"+" "+zhiduan+""+"from"+" "+e.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+" ";

// }

// //结束年份大于开始年份

// else

// {

// //1，先循环到起始时间和起始时间的12月

// s=Convert.ToInt32(sTime);

// x=zstarttime.Substring(0,4)+"12";

// nz=Convert.ToInt32(x);

// for(i=s+1;i<=nz;i++)

// {

// i=i++;

// sql+="select"+" "+zhiduan+""+"from"+" "+i.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+""+"union"+" ";

// }

// //2，循环两者相差年份

// for(i=sy+1;i

// {

// for(j=1;j<=12;j++)

// {

// if(j<10)

// {

// sql+="select"+" "+zhiduan+""+"from"+""+i.ToString()+"0"+j.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+""+"union"+" ";

// }

// else

// {

// sql+="select"+" "+zhiduan+""+"from"+""+i.ToString()+j.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+" "+"union"+"";

// }

// //3，循环到结束的月份

// js=Convert.ToInt32(zendtime.Substring(0,4)+"00");

// for(i=js;i

// {

// i++;

// sql+="select"+" "+zhiduan+""+"from"+" "+i.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+""+"union"+" ";

// }

// sql+="select"+" "+zhiduan+""+"from"+" "+eTime.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+" ";

// }

// //三，取其他表生成生成SQL语句

// else

// {

// //1，先循环到起始时间和起始时间的12月

// s=Convert.ToInt32(sTime);

// x=zstarttime.Substring(0,4)+"12";

// nz=Convert.ToInt32(x);

// for(i=s;i<=nz;i++)

// {

// i=i++;

// sql+="select"+" "+zhiduan+""+"from"+" "+i.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+""+"union"+" ";

// }

// //2，循环两者相差年份

// for(i=sy+1;i

// {

// for(j=1;j<=12;j++)

// {

// if(j<10)

// {

// sql+="select"+" "+zhiduan+""+"from"+""+i.ToString()+"0"+j.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+" "+"union"+"";

// }

// else

// {

// sql+="select"+" "+zhiduan+""+"from"+""+i.ToString()+j.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+" "+"union"+"";

// }

// //3，循环到结束的月份

// js=Convert.ToInt32(zendtime.Substring(0,4)+"00");

// for(i=js;i

// {

// i++;

// sql+="select"+" "+zhiduan+""+"from"+" "+i.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+""+"union"+" ";

// }

// sql+="select"+" "+zhiduan+" "+"from"+""+eTime.ToString()+'_'+tablehz+" "+"where"+""+tiaojiao+" ";

// }

// return sql;

// }

// #endregion

玖、另一个C#操作Oracle数据库的通用类

c#操作oracle的通用类

2009-12-28 来自：百度博客字体大小：【大中小】

摘要：本文为一个c#操作oracle的通用类

using System;

using System.Data;

using System.Data.OracleClient;

using System.Collections;

using System.Reflection;

namespace MyOraComm

{

///

/// ConnDbForOracle 的摘要说明。

///

public class ConnForOracle

{

protected OracleConnection Connection;

private string connectionString;

public ConnForOracle()

{

string connStr;

connStr =

System.Configuration.ConfigurationSettings.

AppSettings["connStr"].ToString();

connectionString = connStr;

Connection = new OracleConnection(connectionString);

}

#region 带参数的构造函数

///

/// 带参数的构造函数

///

/// 数据库联接字符串

public ConnForOracle(string ConnString)

{

string connStr;

connStr =

System.Configuration.ConfigurationSettings.

AppSettings[ConnString].ToString();

Connection = new OracleConnection(connStr);

}

#endregion

#region 打开数据库

///

/// 打开数据库

///

public void OpenConn()

{

if(this.Connection.State!=ConnectionState.Open)

this.Connection.Open();

}

#endregion

#region 关闭数据库联接

///

/// 关闭数据库联接

///

public void CloseConn()

{

if(Connection.State==ConnectionState.Open)

Connection.Close();

}

#endregion

#region 执行SQL语句，返回数据到DataSet中

///

/// 执行SQL语句，返回数据到DataSet中

///

/// sql语句

/// 自定义返回的DataSet表名

/// 返回DataSet

public DataSet ReturnDataSet(string sql,string DataSetName)

{

DataSet dataSet=new DataSet();

OpenConn();

OracleDataAdapter OraDA=new OracleDataAdapter(sql,Connection);

OraDA.Fill(dataSet,DataSetName);

// CloseConn();

return dataSet;

}

#endregion

#region 执行Sql语句,返回带分页功能的dataset

///

/// 执行Sql语句,返回带分页功能的dataset

///

/// Sql语句

/// 每页显示记录数

/// <当前页/param>

/// 返回dataset表名

/// 返回DataSet

public DataSet ReturnDataSet(string sql,int PageSize,

int CurrPageIndex,string DataSetName)

{

DataSet dataSet=new DataSet();

OpenConn();

OracleDataAdapter OraDA=

new OracleDataAdapter(sql,Connection);

OraDA.Fill(dataSet,PageSize * (CurrPageIndex - 1),

PageSize,DataSetName);

// CloseConn();

return dataSet;

}

#endregion

#region 执行SQL语句，返回 DataReader,用之前一定要先.read()打开,然后才能读到数据

///

/// 执行SQL语句，返回 DataReader,用之前一定要先.read()打开,然后才能读到数据

///

/// sql语句

/// 返回一个OracleDataReader

public OracleDataReader ReturnDataReader(String sql)

{

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

returncommand.ExecuteReader(System.Data.CommandBehavior.CloseConnection);

}

#endregion

#region 执行SQL语句，返回记录总数数

///

/// 执行SQL语句，返回记录总数数

///

/// sql语句

/// 返回记录总条数

public int GetRecordCount(string sql)

{

int recordCount = 0;

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

OracleDataReader dataReader = command.ExecuteReader();

while(dataReader.Read())

{

recordCount++;

}

dataReader.Close();

// CloseConn();

return recordCount;

}

#endregion

#region 取当前序列,条件为seq.nextval或seq.currval

///

/// 取当前序列

///

public decimal GetSeq(string seqstr)

{

decimal seqnum = 0;

string sql="select "+seqstr+" from dual";

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

OracleDataReader dataReader = command.ExecuteReader();

if(dataReader.Read())

{

seqnum=decimal.Parse(dataReader[0].ToString());

}

dataReader.Close();

// CloseConn();

return seqnum;

}

#endregion

#region 执行SQL语句,返回所影响的行数

///

/// 执行SQL语句,返回所影响的行数

///

public int ExecuteSQL(string sql)

{

int Cmd=0;

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

try

{

Cmd =command.ExecuteNonQuery();

}

catch

{

}

finally

{

// CloseConn();

}

return Cmd;

}

#endregion

//　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

//　用hashTable对数据库进行insert,update,del操作,注意此时只能

// 用默认的数据库连接"connstr"

//　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

#region 根据表名及哈稀表自动插入数据库用法：Insert("test",ht)

public int Insert(string TableName,Hashtable ht)

{

OracleParameter[] Parms=new OracleParameter[ht.Count];

IDictionaryEnumerator et = ht.GetEnumerator();

DataTable dt=GetTabType(TableName);

System.Data.OracleClient.OracleType otype;

int size=0;

int i=0;

while ( et.MoveNext() ) // 作哈希表循环

{

GetoType(et.Key.ToString().ToUpper(),dt,out otype,out size);

System.Data.OracleClient.OracleParameter op=MakeParam(":"+

et.Key.ToString(),otype,size,et.Value.ToString());

Parms[i]=op; // 添加SqlParameter对象

i=i+1;

}

string str_Sql=GetInsertSqlbyHt(TableName,ht); // 获得插入sql语句

int val=ExecuteNonQuery(str_Sql,Parms);

return val;

}

#endregion

#region 根据相关条件对数据库进行更新操作用法：Update("test","Id=:Id",ht);

public int Update(string TableName,string ht_Where, Hashtable ht)

{

OracleParameter[] Parms=new OracleParameter[ht.Count];

IDictionaryEnumerator et = ht.GetEnumerator();

DataTable dt=GetTabType(TableName);

System.Data.OracleClient.OracleType otype;

int size=0;

int i=0;

// 作哈希表循环

while ( et.MoveNext() )

{

GetoType(et.Key.ToString().ToUpper(),dt,out otype,out size);

System.Data.OracleClient.OracleParameter op=

MakeParam(":"+et.Key.ToString(),otype,size,et.Value.ToString());

Parms[i]=op; // 添加SqlParameter对象

i=i+1;

}

string str_Sql=GetUpdateSqlbyHt(TableName,ht_Where,ht); // 获得插入sql语句

int val=ExecuteNonQuery(str_Sql,Parms);

return val;

}

#endregion

#region del操作

//,注意此处条件个数与hash里参数个数应该一致

//用法：Del("test","Id=:Id",ht)

public int Del(stringTableName,string ht_Where,Hashtable ht)

{

OracleParameter[] Parms=new OracleParameter[ht.Count];

IDictionaryEnumerator et = ht.GetEnumerator();

DataTable dt=GetTabType(TableName);

System.Data.OracleClient.OracleType otype;

int i=0;

int size=0;

// 作哈希表循环

while ( et.MoveNext() )

{

GetoType(et.Key.ToString().ToUpper(),dt,out otype,out size);

System.Data.OracleClient.OracleParameter op=

MakeParam(":"+et.Key.ToString(),et.Value.ToString());

Parms[i]=op; // 添加SqlParameter对象

i=i+1;

}

string str_Sql=GetDelSqlbyHt(TableName,ht_Where,ht); // 获得删除sql语句

int val=ExecuteNonQuery(str_Sql,Parms);

return val;

}

#endregion

//　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

//　＝＝＝＝＝＝＝＝上面三个操作的内部调用函数＝＝＝＝＝＝＝

//　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

#region 根据哈稀表及表名自动生成相应insert语句(参数类型的)

///

/// 根据哈稀表及表名自动生成相应insert语句

///

/// 要插入的表名

/// 哈稀表

/// 返回sql语句

public static string GetInsertSqlbyHt(string TableName,Hashtable ht)

{

string str_Sql="";

int i=0;

int ht_Count=ht.Count; // 哈希表个数

IDictionaryEnumerator myEnumerator = ht.GetEnumerator();

string before="";

string behide="";

while ( myEnumerator.MoveNext() )

{

if (i==0)

{

before="("+myEnumerator.Key;

}

else if (i+1==ht_Count)

{

before=before+","+myEnumerator.Key+")";

}

else

{

before=before+","+myEnumerator.Key;

}

i=i+1;

}

behide="Values"+before.Replace(",",",:").Replace("(","(:");

str_Sql="Insert into "+TableName+before+behide;

return str_Sql;

}

#endregion

#region 根据表名，where条件，哈稀表自动生成更新语句(参数类型的)

public static string GetUpdateSqlbyHt(string Table,

string ht_Where,Hashtable ht)

{

string str_Sql="";

int i=0;

int ht_Count=ht.Count; // 哈希表个数

IDictionaryEnumerator myEnumerator = ht.GetEnumerator();

while ( myEnumerator.MoveNext() )

{

if (i==0)

{

if (ht_Where.ToString().ToLower().IndexOf((myEnumerator.Key+

"=:"+myEnumerator.Key).ToLower())==-1)

{

str_Sql=myEnumerator.Key+"=:"+myEnumerator.Key;

}

else

{

if (ht_Where.ToString().ToLower().IndexOf((":"+

myEnumerator.Key+" ").ToLower())==-1)

{

str_Sql=str_Sql+","+myEnumerator.Key+"=:"+myEnumerator.Key;

}

i=i+1;

}

if (ht_Where==null || ht_Where.Replace("","")=="") // 更新时候没有条件

{

str_Sql="update "+Table+" set "+str_Sql;

}

else

{

str_Sql="update "+Table+" set "+str_Sql+" where"+ht_Where;

}

str_Sql=str_Sql.Replace("set ,","set").Replace("update ,","update ");

return str_Sql;

}

#endregion

#region 根据表名，where条件，哈稀表自动生成del语句(参数类型的)

public static string GetDelSqlbyHt(string Table,

string ht_Where,Hashtable ht)

{

string str_Sql="";

int i=0;

int ht_Count=ht.Count; // 哈希表个数

IDictionaryEnumerator myEnumerator = ht.GetEnumerator();

while ( myEnumerator.MoveNext() )

{

if (i==0)

{

if (ht_Where.ToString().ToLower().IndexOf((myEnumerator.Key+

"=:"+myEnumerator.Key).ToLower())==-1)

{

str_Sql=myEnumerator.Key+"=:"+myEnumerator.Key;

}

else

{

if (ht_Where.ToString().ToLower().IndexOf((":"+

myEnumerator.Key+" ").ToLower())==-1)

{

str_Sql=str_Sql+","+myEnumerator.Key+"=:"+myEnumerator.Key;

}

i=i+1;

}

if (ht_Where==null || ht_Where.Replace("","")=="") // 更新时候没有条件

{

str_Sql="Delete "+Table;

}

else

{

str_Sql="Delete "+Table+" where "+ht_Where;

}

return str_Sql;

}

#endregion

#region 生成oracle参数

///

/// 生成oracle参数

///

/// 字段名

/// 数据类型

/// 数据大小

/// 值

///

public static OracleParameterMakeParam(string ParamName,

System.Data.OracleClient.OracleType otype,int size,Object Value)

{

OracleParameter para=new OracleParameter(ParamName,Value);

para.OracleType=otype;

para.Size=size;

return para;

}

#endregion

#region 生成oracle参数

public static OracleParameter MakeParam(string ParamName,string Value)

{

return new OracleParameter(ParamName, Value);

}

#endregion

#region 根据表结构字段的类型和长度拼装oracle sql语句参数

public static void GetoType(string key,DataTable dt,

out System.Data.OracleClient.OracleType otype,out int size)

{

DataView dv=dt.DefaultView;

dv.RowFilter="column_name='"+key+"'";

string fType=dv[0]["data_type"].ToString().ToUpper();

switch (fType)

{

case "DATE":

otype= OracleType.DateTime;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "CHAR":

otype= OracleType.Char;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "LONG":

otype= OracleType.Double;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "NVARCHAR2":

otype= OracleType.NVarChar;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "VARCHAR2":

otype= OracleType.NVarChar;

size=int.Parse(dv[0]["data_length"].ToString());

break;

default:

otype= OracleType.NVarChar;

size=100;

break;

}

#endregion

#region动态取表里字段的类型和长度,此处没有动态用到connstr,是默认的！by/文少

public System.Data.DataTable GetTabType(string tabnale)

{

string sql="select column_name,data_type,data_length "+

"from all_tab_columns wheretable_name='"+tabnale.ToUpper()+"'";

OpenConn();

return (ReturnDataSet(sql,"dv")).Tables[0];

}

#endregion

#region 执行sql语句

public int ExecuteNonQuery(string cmdText, params OracleParameter[] cmdParms)

{

OracleCommand cmd = new OracleCommand();

OpenConn();

cmd.Connection=Connection;

cmd.CommandText = cmdText;

if (cmdParms != null)

{

foreach (OracleParameter parm in cmdParms)

cmd.Parameters.Add(parm);

}

int val = cmd.ExecuteNonQuery();

cmd.Parameters.Clear();

// conn.CloseConn();

return val;

}

#endregion

//　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

//　＝＝＝＝＝＝＝＝＝内部调用函数完＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

//　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

}

拾、C# Oracle连接操作类

C# Oracle连接操作类

标签：数据库连接类 Oracle 　更新时间：2013-11-18

C# Oracle连接类，操作类代码，可执行超多常用的Oracle数据库操作，包含了基础数据库连接、关闭连接、输出记录集、执行Sql语句，返回带分页功能的dataset、取表里字段的类型和长度等，同时还有哈稀表自动插入数据库等高级任务。需要说明的是：执行SQL语句，返回DataReader,用之前一定要先.read()打开,然后才能读到数据，用hashTable对数据库进行insert,update,del操作,注意此时只能用默认的数据库连接"connstr"。

using System;

using System.Data;

using System.Data.OracleClient;

using System.Collections;

using System.Reflection;

namespace MyOraComm

{

///ConnDbForOracle 的摘要说明。

public class ConnForOracle

{

protected OracleConnection Connection;

private string connectionString;

public ConnForOracle()

{

string connStr;

connStr = System.Configuration.ConfigurationSettings.AppSettings["connStr"].ToString();

connectionString = connStr;

Connection = new OracleConnection(connectionString);

}

#region 带参数的构造函数

/// 带参数的构造函数

/// 数据库联接字符串

public ConnForOracle(string ConnString)

{

string connStr;

connStr =System.Configuration.ConfigurationSettings.AppSettings[ConnString].ToString();

Connection = new OracleConnection(connStr);

}

#endregion

#region 打开数据库

/// 打开数据库

public void OpenConn()

{

if(this.Connection.State!=ConnectionState.Open)

this.Connection.Open();

}

#endregion

#region 关闭数据库联接

/// 关闭数据库联接

public void CloseConn()

{

if(Connection.State==ConnectionState.Open)

Connection.Close();

}

#endregion

#region 执行SQL语句，返回数据到DataSet中

/// 执行SQL语句，返回数据到DataSet中

/// sql语句

/// 自定义返回的DataSet表名

/// 返回DataSet

public DataSet ReturnDataSet(string sql,string DataSetName)

{

DataSet dataSet=new DataSet();

OpenConn();

OracleDataAdapter OraDA=new OracleDataAdapter(sql,Connection);

OraDA.Fill(dataSet,DataSetName);

// CloseConn();

return dataSet;

}

#endregion

#region 执行Sql语句,返回带分页功能的dataset

/// 执行Sql语句,返回带分页功能的dataset

/// Sql语句

/// 每页显示记录数

/// <当前页/param>

/// 返回dataset表名

/// 返回DataSet

public DataSet ReturnDataSet(string sql,int PageSize,intCurrPageIndex,string DataSetName)

{

DataSet dataSet=new DataSet();

OpenConn();

OracleDataAdapter OraDA=new OracleDataAdapter(sql,Connection);

OraDA.Fill(dataSet,PageSize * (CurrPageIndex - 1),PageSize,DataSetName);

// CloseConn();

return dataSet;

}

#endregion

#region 执行SQL语句，返回 DataReader,用之前一定要先.read()打开,然后才能读到数据

/// 执行SQL语句，返回 DataReader,用之前一定要先.read()打开,然后才能读到数据

/// sql语句

/// 返回一个OracleDataReader

public OracleDataReader ReturnDataReader(String sql)

{

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

returncommand.ExecuteReader(System.Data.CommandBehavior.CloseConnection);

}

#endregion

#region 执行SQL语句，返回记录总数数

/// 执行SQL语句，返回记录总数数

/// sql语句

/// 返回记录总条数

public int GetRecordCount(string sql)

{

int recordCount = 0;

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

OracleDataReader dataReader = command.ExecuteReader();

while(dataReader.Read())

{

recordCount++;

}

dataReader.Close();

//CloseConn();

return recordCount;

}

#endregion

#region 取当前序列,条件为seq.nextval或seq.currval

///

/// 取当前序列

public decimal GetSeq(string seqstr)

{

decimal seqnum = 0;

string sql="select "+seqstr+" from dual";

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

OracleDataReader dataReader = command.ExecuteReader();

if(dataReader.Read())

{

seqnum=decimal.Parse(dataReader[0].ToString());

}

dataReader.Close();

// CloseConn();

return seqnum;

}

#endregion

#region 执行SQL语句,返回所影响的行数

/// 执行SQL语句,返回所影响的行数

public int ExecuteSQL(string sql)

{

int Cmd=0;

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

try

{

Cmd =command.ExecuteNonQuery();

}

catch

{

}

finally

{

//CloseConn();

}

return Cmd;

}

#endregion

//＝＝用hashTable对数据库进行insert,update,del操作,注意此时只能用默认的数据库连接"connstr"

#region 根据表名及哈稀表自动插入数据库用法：Insert("test",ht)

public int Insert(string TableName,Hashtable ht)

{

OracleParameter[] Parms=new OracleParameter[ht.Count];

IDictionaryEnumerator et = ht.GetEnumerator();

DataTable dt=GetTabType(TableName);

System.Data.OracleClient.OracleType otype;

int size=0;

int i=0;

while ( et.MoveNext() ) // 作哈希表循环

{

GetoType(et.Key.ToString().ToUpper(),dt,out otype,out size);

System.Data.OracleClient.OracleParameterop=MakeParam(":"+et.Key.ToString(),otype,size,et.Value.ToString());

Parms[i]=op; // 添加SqlParameter对象

i=i+1;

}

string str_Sql=GetInsertSqlbyHt(TableName,ht); // 获得插入sql语句

int val=ExecuteNonQuery(str_Sql,Parms);

return val;

}

#endregion

#region 根据相关条件对数据库进行更新操作用法：Update("test","Id=:Id",ht);

public int Update(string TableName,string ht_Where, Hashtable ht)

{

OracleParameter[] Parms=new OracleParameter[ht.Count];

IDictionaryEnumerator et = ht.GetEnumerator();

DataTable dt=GetTabType(TableName);

System.Data.OracleClient.OracleType otype;

int size=0;

int i=0;

// 作哈希表循环

while ( et.MoveNext() )

{

GetoType(et.Key.ToString().ToUpper(),dt,out otype,out size);

System.Data.OracleClient.OracleParameterop=MakeParam(":"+et.Key.ToString(),otype,size,et.Value.ToString());

Parms[i]=op; // 添加SqlParameter对象

i=i+1;

}

string str_Sql=GetUpdateSqlbyHt(TableName,ht_Where,ht); // 获得插入sql语句

int val=ExecuteNonQuery(str_Sql,Parms);

return val;

}

#endregion

#region del操作,注意此处条件个数与hash里参数个数应该一致用法：Del("test","Id=:Id",ht)

public int Del(stringTableName,string ht_Where,Hashtable ht)

{

OracleParameter[] Parms=new OracleParameter[ht.Count];

IDictionaryEnumerator et = ht.GetEnumerator();

DataTable dt=GetTabType(TableName);

System.Data.OracleClient.OracleType otype;

int i=0;

int size=0;

// 作哈希表循环

while ( et.MoveNext() )

{

GetoType(et.Key.ToString().ToUpper(),dt,out otype,out size);

System.Data.OracleClient.OracleParameterop=MakeParam(":"+et.Key.ToString(),et.Value.ToString());

Parms[i]=op; // 添加SqlParameter对象

i=i+1;

}

string str_Sql=GetDelSqlbyHt(TableName,ht_Where,ht); // 获得删除sql语句

int val=ExecuteNonQuery(str_Sql,Parms);

return val;

}

#endregion

//　＝＝＝＝＝＝＝＝上面三个操作的内部调用函数＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

#region 根据哈稀表及表名自动生成相应insert语句(参数类型的)

/// 根据哈稀表及表名自动生成相应insert语句

/// 要插入的表名

/// 哈稀表

/// 返回sql语句

publicstatic string GetInsertSqlbyHt(string TableName,Hashtable ht)

{

string str_Sql="";

int i=0;

int ht_Count=ht.Count; // 哈希表个数

IDictionaryEnumerator myEnumerator = ht.GetEnumerator();

string before="";

string behide="";

while ( myEnumerator.MoveNext() )

{

if (i==0)

{

before="("+myEnumerator.Key;

}

else if (i+1==ht_Count)

{

before=before+","+myEnumerator.Key+")";

}

else

{

before=before+","+myEnumerator.Key;

}

i=i+1;

}

behide="Values"+before.Replace(",",",:").Replace("(","(:");

str_Sql="Insert into "+TableName+before+behide;

return str_Sql;

}

#endregion

#region 根据表名，where条件，哈稀表自动生成更新语句(参数类型的)

public static string GetUpdateSqlbyHt(string Table,stringht_Where,Hashtable ht)

{

string str_Sql="";

int i=0;

int ht_Count=ht.Count; // 哈希表个数

IDictionaryEnumerator myEnumerator = ht.GetEnumerator();

while ( myEnumerator.MoveNext() )

{

if (i==0)

{

if(ht_Where.ToString().ToLower().IndexOf((myEnumerator.Key+"=:"+myEnumerator.Key).ToLower())==-1)

{

str_Sql=myEnumerator.Key+"=:"+myEnumerator.Key;

}

else

{

if (ht_Where.ToString().ToLower().IndexOf((":"+myEnumerator.Key+"").ToLower())==-1)

{

str_Sql=str_Sql+","+myEnumerator.Key+"=:"+myEnumerator.Key;

}

i=i+1;

}

if (ht_Where==null || ht_Where.Replace("","")=="") // 更新时候没有条件

{

str_Sql="update "+Table+" set "+str_Sql;

}

else

{

str_Sql="update "+Table+" set "+str_Sql+" where"+ht_Where;

}

str_Sql=str_Sql.Replace("set ,","set").Replace("update ,","update ");

return str_Sql;

}

#endregion

#region 根据表名，where条件，哈稀表自动生成del语句(参数类型的)

publicstatic string GetDelSqlbyHt(string Table,string ht_Where,Hashtable ht)

{

string str_Sql="";

int i=0;

int ht_Count=ht.Count; // 哈希表个数

IDictionaryEnumerator myEnumerator = ht.GetEnumerator();

while ( myEnumerator.MoveNext() )

{

if (i==0)

{

if(ht_Where.ToString().ToLower().IndexOf((myEnumerator.Key+"=:"+myEnumerator.Key).ToLower())==-1)

{

str_Sql=myEnumerator.Key+"=:"+myEnumerator.Key;

}

else

{

if (ht_Where.ToString().ToLower().IndexOf((":"+myEnumerator.Key+"").ToLower())==-1)

{

str_Sql=str_Sql+","+myEnumerator.Key+"=:"+myEnumerator.Key;

}

i=i+1;

}

if (ht_Where==null || ht_Where.Replace("","")=="") // 更新时候没有条件

{

str_Sql="Delete "+Table;

}

else

{

str_Sql="Delete "+Table+" where "+ht_Where;

}

return str_Sql;

}

#endregion

#region 生成oracle参数

///

/// 生成oracle参数

/// 字段名

/// 数据类型

/// 数据大小

/// 值

public static OracleParameter MakeParam(stringParamName,System.Data.OracleClient.OracleType otype,int size,Object Value)

{

OracleParameter para=new OracleParameter(ParamName,Value);

para.OracleType=otype;

para.Size=size;

return para;

}

#endregion

#region生成oracle参数

public static OracleParameter MakeParam(string ParamName,string Value)

{

return new OracleParameter(ParamName, Value);

}

#endregion

#region 根据表结构字段的类型和长度拼装oracle sql语句参数

public static void GetoType(string key,DataTable dt,outSystem.Data.OracleClient.OracleType otype,out int size)

{

DataView dv=dt.DefaultView;

dv.RowFilter="column_name='"+key+"'";

string fType=dv[0]["data_type"].ToString().ToUpper();

switch (fType)

{

case "DATE":

otype= OracleType.DateTime;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "CHAR":

otype= OracleType.Char;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "LONG":

otype= OracleType.Double;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "NVARCHAR2":

otype= OracleType.NVarChar;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "VARCHAR2":

otype= OracleType.NVarChar;

size=int.Parse(dv[0]["data_length"].ToString());

break;

default:

otype= OracleType.NVarChar;

size=100;

break;

}

#endregion

#region动态取表里字段的类型和长度,此处没有动态用到connstr,是默认的！by/文少

public System.Data.DataTable GetTabType(string tabnale)

{

string sql="select column_name,data_type,data_length from all_tab_columns wheretable_name='"+tabnale.ToUpper()+"'";

OpenConn();

return (ReturnDataSet(sql,"dv")).Tables[0];

}

#endregion

#region 执行sql语句

public int ExecuteNonQuery(string cmdText, params OracleParameter[]cmdParms)

{

OracleCommand cmd = new OracleCommand();

OpenConn();

cmd.Connection=Connection;

cmd.CommandText = cmdText;

if (cmdParms != null)

{

foreach (OracleParameter parm in cmdParms)

cmd.Parameters.Add(parm);

}

int val = cmd.ExecuteNonQuery();

cmd.Parameters.Clear();

//conn.CloseConn();

return val;

}

#endregion

}

壹、ORACLE817安装（服务器端/客户端）... 1

贰、ORACLE817配置（服务器端）... 3

叁、ORACLE817配置（客户端）... 5

肆、安装的oracle8i怎么全部卸载... 8

伍、Oracle数据库体系结构... 10

陆、ORACLE数据类型... 14

柒、c#通过oledb连接Oracle. 27

捌、一个C#操作Oracle的通用类... 29

玖、另一个C#操作Oracle数据库的通用类... 45

拾、C#Oracle连接操作类... 68

壹、ORACLE817安装（服务器端/客户端）

1、将光盘放入光驱，自动弹出安装界面，选择开始安装；

2、欢迎：下一步；

3、文件定位，所有内容默认，如果更改oracle安装路径，在目标路径中进行更改，下一步；

4、可用产品：服务器端选择第一个Oracle8i Enterprise Edition 8.1.7.0.0，客户端选择第二个Oracle8i Client8.1.7.0.0 下一步；

5、安装类型：选择典型（779MB），下一步；

6、数据库标识：全局数据库名：ORA817，SID：ORA817，下一步

7、摘要：安装

8、开始安装…………………….等待

9、安装进度完成后，开始自动配置并启动数据库，继续等待

当弹出下面对话框时，表明ORACLE安装成功

确定并退出

贰、ORACLE817配置（服务器端）

一、登陆ORACLE

开始—>程序—> Oracle-OraHome81—> Database Administration—> DBA Studio

默认，以独立模式启动DBAStudio，点击确定登陆

登陆后，在左面的树形结构中双击我们建立的全局数据库名称，在此为ORA817，登陆用户为internal，口令为oracle，不区分大小写。

二、创建表空间

三、创建用户

叁、ORACLE817配置（客户端）

开始—>程序—> Oracle-OraHome81—> Network Administration—> Net8 Assistant

打开Net8后，选择本地—>服务名称，点击右面的绿色加号，创建服务名，弹出向导，在网络服务名中输入JCJXGL，点击下一步

选择TCP/IP网络协议，点击下一步

在协议设置中，填写服务器主机名：服务器的计算机名或IP地址，端口号默认1521不变，点击下一步

导入\导出数据库：

开始—>运行cmd，打开命令提示符状态

导出：EXP JNJWD / JNJWD FILE= JNJWD.DMP回车

导入：IMP JNJWD / JNJWD FROMUSER= JNJWDFILE= JNJWD.DMP

肆、安装的oracle 8i怎么全部卸载

软件环境：

1、Windows2000+ORACLE 8.1.7

2、ORACLE安装路径为：C:\ORACLE

实现方法：

1、开始－＞设置－＞控制面板－＞管理工具－＞服务

停止所有Oracle服务。

2、开始－＞程序－＞Oracle - OraHome81－＞Oracle InstallationProducts－＞

Universal Installer

卸装所有Oracle产品，但Universal Installer本身不能被删除

5、运行regedit，选择HKEY_LOCAL_MACHINE\SOFTWARE\ORACLE，按del键删除这个入口。

6、运行regedit，选择HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services，滚动

这个列表，删除所有Oracle入口。

7、运行refedit，

HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\Eventlog\Application，

删除所有Oracle入口。

8、开始－＞设置－＞控制面板－＞系统－＞高级－＞环境变量

删除环境变量CLASSPATH和PATH中有关Oracle的设定

9、从桌面上、STARTUP（启动）组、程序菜单中，删除所有有关Oracle的组和图标

10、删除\ProgramFiles\Oracle目录

11、重新启动计算机，重起后才能完全删除Oracle所在目录

12、删除与Oracle有关的文件，选择Oracle所在的缺省目录C:\Oracle，删除这个入

口目录及所有子目录，并从Windows 2000目录（一般为C:\WINNT）下删除以下文

件ORACLE.INI、oradim73.INI、oradim80.INI、oraodbc.ini等等。

13、WIN.INI文件中若有[ORACLE]的标记段，删除该段

14、如有必要，删除所有Oracle相关的ODBC的DSN

15、到事件查看器中，删除Oracle相关的日志

说明：

如果有个别DLL文件无法删除的情况，则不用理会，重新启动，开始新的安装，

安装时，选择一个新的目录，则，安装完毕并重新启动后，老的目录及文件就可以删除掉了。

(t114)

在Windows NT/2000下清除Oracle8i运行环境（重新安装前的准备工作）：

1. 删除Oracle8i注册表：
regedit.exe => HKLM => Software => ORACLE

2. 删除Oracle8i服务：
regedit.exe => HKLM => System => CurrentControlset => Services=> 以Oracle开头的服务

3. 删除Oracle8i事件日志：
regedit.exe => HKLM => System => CurrentControlset => Services=> Eventlog => Application => 以Oracle开始的事件

4. 删除Windows NT/2000安装磁盘\Program Files\Oracle目录。

5. 删除Oracle8i环境变量
控制面板 => 系统 => 高级 => 环境变量
(1) 删除CLASSPATH
(2) 编辑PATH，将其中与Oracle有关系的路径删除。

6. 删除Oracle8i菜单

7. 重新启动Windows NT/2000，停止服务。

8. 删除Oracle8i主目录。

伍、Oracle数据库体系结构

Oracle数据库的体系结构包括四个方面：数据库的物理结构、逻辑结构、内存结构及进程。

　　1. 物理结构

　　物理数据库结构是由构成数据库的操作系统文件所决定，Oracle数据库文件包括：

　　数据文件（DataFile）

　　数据文件用来存储数据库中的全部数据，例如数据库表中的数据和索引数据.通常以为*.dbf格式，例如:userCIMS.dbf 。

　　日志文件（RedoLog File）

　　控制文件（ControlFile）

　　配置文件

　　配置文件记录Oracle数据库运行时的一些重要参数，如：数据块的大小，内存结构的配置等。名字通常为init*.ora 格式，如：initCIMS.ora 。

　　2 逻辑结构

表空间（tablespace）

　　一个表空间包含许多段，每个段有一些可以不连续的区组成，每个区由一组连续的数据块组成，数据块是数据库进行操作的最小单位。

　　每个表空间对应一个或多个数据文件，每个数据文件只能属于一个表空间。

　　数据库块（databaseblock）

　　区（extent）

　　区是由一组连续的数据块所组成的数据库存储空间分配的逻辑单位。

　　段（segment）

　　模式对象（schemaobject）

　　Oracle数据库的模式对象包括表、视图、序列、同意词、索引、触发器、存储.过程等，关于它们将重点在后面章节介绍。

　　3．Oracle Server系统进程与内存结构

　　为了提高系统性能，更好地实现多用户功能，ORACLE还在系统后台启动一些后台进程，用于数据库数据操作。

　　系统进程的后台进程主要包括：

　　SMON 系统监控进程：（system monitor）负责完成自动实例恢复和回收分类（sort）表空间。

　　PMON 进程监控进程：（process monitor）实现用户进程故障恢复、清理内存区和释放该进程所需资源等。

　　LGWR 日志文件写进程：是日志缓冲区的管理进程，负责把日志缓冲区中的日志项写入磁盘中的日志文件上。每个实例只有一个LGWR进程。

　　RECO 恢复进程：是在具有分布式选项时使用的一个进程，主要用于解决引用分布式事务时所出现的故障。它只能在允许分布式事务的系统中出现。

　　LCKn 封锁进程：用于并行服务器系统，主要完成实例之间的封锁。

　　内存结构（SGA）

　　SGA中内存根据存放信息的不同，可以分为如下几个区域：

（见图 SGA中内存区域.gif）

　　Cursors：一些内存指针，执行待处理的SQL语句

陆、ORACLE数据类型

字段类型中文说明限制条件其它说明

CHAR 固定长度字符串最大长度2000 bytes

VARCHAR2 可变长度的字符串最大长度4000 bytes 可做索引的最大长度749

NCHAR 根据字符集而定的固定长度字符串最大长度2000 bytes

NVARCHAR2 根据字符集而定的可变长度字符串最大长度4000 bytes

DATE 日期（日-月-年） DD-MM-YY（HH-MI-SS）经过严格测试，无千虫问题

LONG 超长字符串最大长度2G（231-1）足够存储大部头著作

RAW 固定长度的二进制数据最大长度2000 bytes 可存放多媒体图象声音等

LONG RAW 可变长度的二进制数据最大长度2G 同上

BLOB 二进制数据最大长度4G

CLOB 字符数据最大长度4G

NCLOB 根据字符集而定的字符数据最大长度4G

BFILE 存放在数据库外的二进制数据最大长度4G

ROWID 数据表中记录的唯一行号 10 bytes ********.****.****格式，*为0或1

NROWID 二进制数据表中记录的唯一行号最大长度4000 bytes

NUMBER(P,S) 数字类型 P为整数位，S为小数位

DECIMAL(P,S) 数字类型 P为整数位，S为小数位

INTEGER 整数类型小的整数

FLOAT 浮点数类型 NUMBER(38)，双精度

REAL 实数类型 NUMBER(63)，精度更高

数据类型	参数	描述
char(n)	n=1 to 2000字节	定长字符串，n字节长，如果不指定长度，缺省为1个字节长（一个汉字为2字节）
varchar2(n)	n=1 to 4000字节	可变长的字符串，具体定义时指明最大长度n，这种数据类型可以放数字、字母以及ASCII码字符集(或者EBCDIC等数据库系统接受的字符集标准)中的所有符号。如果数据长度没有达到最大值n，Oracle 8i会根据数据大小自动调节字段长度，如果你的数据前后有空格，Oracle 8i会自动将其删去。VARCHAR2是最常用的数据类型。可做索引的最大长度3209。
number(m,n)	m=1 to 38 n=-84 to 127	可变长的数值列，允许0、正值及负值，m是所有有效数字的位数，n是小数点以后的位数。如：number(5,2)，则这个字段的最大值是99,999，如果数值超出了位数限制就会被截取多余的位数。如：number(5,2)，但在一行数据中的这个字段输入575.316，则真正保存到字段中的数值是575.32。如：number(3,0)，输入575.316，真正保存的数据是575。
date	无	从公元前4712年1月1日到公元4712年12月31日的所有合法日期， Oracle 8i其实在内部是按7个字节来保存日期数据，在定义中还包括小时、分、秒。缺省格式为DD-MON-YY，如07-11月-00 表示2000年11月7日。
long	无	可变长字符列，最大长度限制是2GB，用于不需要作字符串搜索的长串数据，如果要进行字符搜索就要用varchar2类型。 long是一种较老的数据类型，将来会逐渐被BLOB、CLOB、NCLOB等大的对象数据类型所取代。
raw(n)	n=1 to 2000	可变长二进制数据，在具体定义字段的时候必须指明最大长度n，Oracle 8i用这种格式来保存较小的图形文件或带格式的文本文件，如Miceosoft Word文档。 raw是一种较老的数据类型，将来会逐渐被BLOB、CLOB、NCLOB等大的对象数据类型所取代。
long raw	无	可变长二进制数据，最大长度是2GB。Oracle 8i用这种格式来保存较大的图形文件或带格式的文本文件，如Miceosoft Word文档，以及音频、视频等非文本文件。在同一张表中不能同时有long类型和long raw类型，long raw也是一种较老的数据类型，将来会逐渐被BLOB、CLOB、NCLOB等大的对象数据类型所取代。
blob clob nclob	无	三种大型对象(LOB)，用来保存较大的图形文件或带格式的文本文件，如Miceosoft Word文档，以及音频、视频等非文本文件，最大长度是4GB。 LOB有几种类型，取决于你使用的字节的类型，Oracle 8i实实在在地将这些数据存储在数据库内部保存。可以执行读取、存储、写入等特殊操作。
bfile	无	在数据库外部保存的大型二进制对象文件，最大长度是4GB。这种外部的LOB类型，通过数据库记录变化情况，但是数据的具体保存是在数据库外部进行的。 Oracle 8i可以读取、查询BFILE，但是不能写入。大小由操作系统决定。

数据类型是列或存储过程中的一个属性。

Oracle支持的数据类型可以分为三个基本种类：字符数据类型、数字数据类型以及表示其它数据的数据类型。

字符数据类型

Oracle推荐使用VARCHAR2

在Oracle 9i中，可以以字符而不是字节为单位表示NCHAR和NVARCHAR2列的长度。

CLOB和NCLOB CLOB和NCLOB数据类型可以存储多达4GB的字符数据。NCLOB数据类型可存储NLS数据。

数字数据类型

Oracle使用标准、可变长度的内部格式来存储数字。这个内部格式精度可以高达38位。

日期数据类型

Oracle标准日期格式为：DD-MON-YY HH:MI:SS

其它的数据类型

列或变量可以定义成ROWID数据类型，但是Oracle不能保证该列或变量的值是一个有效的ROWID。

LOB（大型对象）数据类型，可以保存4GB的信息。LOB有以下3中类型：

，只能存储字符数据

，保存本地语言字符集数据

，以二进制信息保存数据

可以指定将一个LOB数据保存在Oracle数据库内，还是指向一个包含次数据的外部文件。

LOB可以参与事务。管理LOB中的数据必须通过DBMS_LOB PL/SQL内置软件包或者OGI接口。

为了便于将LONG数据类型转换成LOB，Oracle 9i包含许多同时支持LOB和LONG的函数，喊包括一个ALTER TABLE语句的新选择，它允许将LONG数据类型自动转换成LOB。

BFILE

BFILE数据类型用做指向存储在Oracle数据库以外的文件的指针。

XML Type

用户自定义数据

从Oracle 8以后，用户可以定义自己的复杂数据类型，它们由Oracle基本数据类型组合而成。

AnyType、AnyData和AnyDataSet

类型转换

Oracle会自动将某些数据类型转换成其他的数据类型，转换取决于包括该值的SQL语句。

数据转换还可以通过Oracle的类型转换函数显示地进行。

连接与比较

在大多数平台上Oracle SQL中的连接操作符用两条竖线（||）表示。连接是将两个字符值连接。Oracle的自动类型转换功能使得两个数字值也可以进行连接。

NULL

任何数据类型都可以赋予NULL值。NULL值引入了SQL运算的三态逻辑。如果比较的一方是NULL值，那么会出现3种状态：TURE、FALSE以及两者都不是。

因为NULL值不等于0或其他任何值，所以测试某个数据是否为NULL值只能通过关系运算符IS NULL来进行。

number(p,s)

p:1~38

s:-84~127

p>0，对s分2种情况：1. s>0

精确到小数点右边s位，并四舍五入。然后检验有效数位是否<=p；如果s>p，小数点右边至少有s-p个0填充。

2. s<0

精确到小数点左边s位，并四舍五入。然后检验有效数位是否<=p+|s|

123.2564 NUMBER 123.2564

1234.9876 NUMBER(6,2) 1234.99

12345.12345 NUMBER(6,2) Error

1234.9876 NUMBER(6) 1235

12345.345 NUMBER(5,-2) 12300

1234567 NUMBER(5,-2) 1234600

12345678 NUMBER(5,-2) Error

123456789 NUMBER(5,-4) 123460000

1234567890 NUMBER(5,-4) Error

12345.58 NUMBER(*, 1) 12345.6

0.1 NUMBER(4,5) Error

0.01234567 NUMBER(4,5) 0.01235

0.09999 NUMBER(4,5) 0.09999

oracle 的命名规则：
1、要以字母开头
2、包含字母和数字，以及# $
3、不能超过30个字符

oracle基本数据类型

数据类型	参数	描述
char(n)	n=1 to 2000字节	定长字符串，n字节长，如果不指定长度，缺省为1个字节长（一个汉字为2字节）
varchar2(n)	n=1 to 4000字节	可变长的字符串，具体定义时指明最大长度n，这种数据类型可以放数字、字母以及ASCII码字符集(或者EBCDIC等数据库系统接受的字符集标准)中的所有符号。如果数据长度没有达到最大值n，Oracle 8i会根据数据大小自动调节字段长度，如果你的数据前后有空格，Oracle 8i会自动将其删去。VARCHAR2是最常用的数据类型。可做索引的最大长度3209。
number(m,n)	m=1 to 38 n=-84 to 127	可变长的数值列，允许0、正值及负值，m是所有有效数字的位数，n是小数点以后的位数。如：number(5,2)，则这个字段的最大值是99,999，如果数值超出了位数限制就会被截取多余的位数。如：number(5,2)，但在一行数据中的这个字段输入575.316，则真正保存到字段中的数值是575.32。如：number(3,0)，输入575.316，真正保存的数据是575。
date	无	从公元前4712年1月1日到公元4712年12月31日的所有合法日期， Oracle 8i其实在内部是按7个字节来保存日期数据，在定义中还包括小时、分、秒。缺省格式为DD-MON-YY，如07-11月-00 表示2000年11月7日。
long	无	可变长字符列，最大长度限制是2GB，用于不需要作字符串搜索的长串数据，如果要进行字符搜索就要用varchar2类型。 long是一种较老的数据类型，将来会逐渐被BLOB、CLOB、NCLOB等大的对象数据类型所取代。
raw(n)	n=1 to 2000	可变长二进制数据，在具体定义字段的时候必须指明最大长度n，Oracle 8i用这种格式来保存较小的图形文件或带格式的文本文件，如Miceosoft Word文档。 raw是一种较老的数据类型，将来会逐渐被BLOB、CLOB、NCLOB等大的对象数据类型所取代。
long raw	无	可变长二进制数据，最大长度是2GB。Oracle 8i用这种格式来保存较大的图形文件或带格式的文本文件，如Miceosoft Word文档，以及音频、视频等非文本文件。在同一张表中不能同时有long类型和long raw类型，long raw也是一种较老的数据类型，将来会逐渐被BLOB、CLOB、NCLOB等大的对象数据类型所取代。
blob clob nclob	无	三种大型对象(LOB)，用来保存较大的图形文件或带格式的文本文件，如Miceosoft Word文档，以及音频、视频等非文本文件，最大长度是4GB。 LOB有几种类型，取决于你使用的字节的类型，Oracle 8i实实在在地将这些数据存储在数据库内部保存。可以执行读取、存储、写入等特殊操作。
bfile	无	在数据库外部保存的大型二进制对象文件，最大长度是4GB。这种外部的LOB类型，通过数据库记录变化情况，但是数据的具体保存是在数据库外部进行的。 Oracle 8i可以读取、查询BFILE，但是不能写入。大小由操作系统决定。

oracle 数据库中讨论char ,varchar ,varchar2 数据类型!

这3种字符串数据类型是我们使用最多的，我们在数据库设计时到底该怎么使用了？

首先我们先来分析3个数据类型的说明：

1。char

CHAR的长度是固定的,最长2000个字符。

2。varchar 和 varchar2

其次也有人认为varchar是最大长度为2000的可变字符串（和sql server中的varchar一致），而varchar2最大长度为4000。

知道了他们的特点我们就来讨论下使用区别

1.char和varchar、varchar2

由于varchar和varchar2用途类似，我们先来讨论char和他们的使用区别：

当然还有一种情况就是象身份证这种长度几乎不变的字段可以考虑使用char，以获得更高的效率。

2。varchar和varchar2

因为oracle保证在任何版本中该数据类型向上和向下兼容，但不保证varchar，还有其他数据中一般都有varchar这个数据类型。

所以我得出了以下结论：

如果想在oracle新版本的数据库兼容就不要用varchar,如果想和oracle之外其他数据库兼容就不要用varchar2。

ORACLE中的数据类型分类

Oracle数据类型总结比较全(备注转载)

柒、c#通过oledb连接Oracle

先装oracle客户端

1、控制面板->管理工具->数据源(ODBC)->添加数据源->选择oracle 客户端

Data Source Name 可以任意起名，推荐和SID一样

Description 描述

TNS Service Name 下拉菜单中会自动显示环境变量TNS_ADMIN所指目录下的tnsnames.ora文件中SERVICE_NAME的名称，也就是要连接的SID UserID 用户名

2、代码

string ConnectionString = "DataSource=orcl; User Id=SCOTT; Password=scott"; //连接字符串

OracleConnection conn = newOracleConnection(ConnectionString); //创建一个新连接

try

{

conn.Open(); //打开连接

OracleCommand cmd = conn.CreateCommand();

cmd.CommandText = "select * fromemp"; //SQL语句

OracleDataReader rs = cmd.ExecuteReader();

while (rs.Read()) //读取数据，如果rs.Read()返回为false的话，就说明到记录集的尾部了

{

MessageBox.Show(rs.GetString(1));

}

rs.Close();

}

catch (Exception e)

{

MessageBox.Show(e.Message);

}

finally

{

conn.Close();

}

Oracle

ODBC

New version:

"Driver={Microsoft ODBC forOracle};Server=OracleServer.world;Uid=Username;Pwd=asdasd;"

Old version:

"Driver={Microsoft ODBC Driver forOracle};ConnectString=OracleServer.world;Uid=myUsername;Pwd=myPassword;"

OLEDB, OleDbConnection (.NET)

Standard security:

"Provider=msdaora;DataSource=MyOracleDB;User Id=UserName;Password=asdasd;"

This one's from Microsoft, the followingare from Oracle

Standard Security:

"Provider=OraOLEDB.Oracle;DataSource=MyOracleDB;User Id=Username;Password=asdasd;"

Trusted Connection:

"Provider=OraOLEDB.Oracle;DataSource=MyOracleDB;OSAuthent=1;"

OracleConnection (.NET)

Standard:

"Data Source=Oracle8i;IntegratedSecurity=yes";

This one works only with Oracle 8i release3 or later

Declare the OracleConnection:

C#:

using System.Data.OracleClient;

OracleConnection oOracleConn = newOracleConnection();

oOracleConn.ConnectionString = "myconnectionstring";

oOracleConn.Open();

VB.NET:

Imports System.Data.OracleClient

Dim oOracleConn As OracleConnection = NewOracleConnection()

oOracleConn.ConnectionString = "myconnectionstring"

oOracleConn.Open()

Data Shape

MS Data Shape:

"Provider=MSDataShape.1;PersistSecurity Info=False;Data Provider=MSDAORA;Data Source=orac;userid=username;password=mypw"

捌、一个C#操作Oracle的通用类

using System;

using System.Data;

using System.Data.OracleClient;

using System.Web.UI.WebControls;

namespace SiFenManager.Util

{

///

/// 数据库通用操作类

///

public class Database

{

protected OracleConnection con;//连接对象

public Database()

{

con=newOracleConnection(DafangFramework.AppConfig.DataBaseConnectionString);

}

public Database(string constr)

{

con=new OracleConnection(constr);

}

#region 打开数据库连接

///

/// 打开数据库连接

///

private void Open()

{

//打开数据库连接

if(con.State==ConnectionState.Closed)

{

try

{

//打开数据库连接

con.Open();

}

catch(Exception e)

{

throw e;

}

#endregion

#region 关闭数据库连接

///

/// 关闭数据库连接

///

private void Close()

{

//判断连接的状态是否已经打开

if(con.State==ConnectionState.Open)

{

con.Close();

}

#endregion

#region 执行查询语句，返回OracleDataReader ( 注意：调用该方法后，一定要对OracleDataReader进行Close )

///

/// 执行查询语句，返回OracleDataReader ( 注意：调用该方法后，一定要对OracleDataReader进行Close )

///

/// 查询语句

/// OracleDataReader

public OracleDataReaderExecuteReader(string sql)

{

OracleDataReader myReader;

Open();

OracleCommand cmd = new OracleCommand(sql,con);

myReader =cmd.ExecuteReader(CommandBehavior.CloseConnection);

return myReader;

}

#endregion

#region 执行带参数的SQL语句

///

/// 执行SQL语句，返回影响的记录数

///

/// SQL语句

/// 影响的记录数

public int ExecuteSql(string sql,params OracleParameter[] cmdParms)

{

OracleCommand cmd = new OracleCommand();

{

try

{

PrepareCommand(cmd, con, null, sql,cmdParms);

int rows = cmd.ExecuteNonQuery();

cmd.Parameters.Clear();

return rows;

}

catch(System.Data.OracleClient.OracleException e)

{

throw e;

}

#endregion

#region 执行带参数的SQL语句

///

/// 执行不带参数的SQL语句

///

/// SQL语句

public void ExecuteSql(stringsql)

{

OracleCommand cmd = newOracleCommand(sql,con);

try

{

Open();

cmd.ExecuteNonQuery();

Close();

}

catch(System.Data.OracleClient.OracleException e)

{

Close();

throw e;

}

#endregion

#region 执行SQL语句，返回数据到DataSet中

///

/// 执行SQL语句，返回数据到DataSet中

///

/// sql语句

/// 返回DataSet

public DataSet GetDataSet(stringsql)

{

DataSet ds=new DataSet();

try

{

Open();//打开数据连接

OracleDataAdapter adapter=new OracleDataAdapter(sql,con);

adapter.Fill(ds);

}

catch//(Exception ex)

{

}

finally

{

Close();//关闭数据库连接

}

return ds;

}

#endregion

#region 执行SQL语句，返回数据到自定义DataSet中

///

/// 执行SQL语句，返回数据到DataSet中

///

/// sql语句

/// 自定义返回的DataSet表名

/// 返回DataSet

public DataSet GetDataSet(stringsql,string DataSetName)

{

DataSet ds=new DataSet();

Open();//打开数据连接

OracleDataAdapter adapter=new OracleDataAdapter(sql,con);

adapter.Fill(ds,DataSetName);

Close();//关闭数据库连接

return ds;

}

#endregion

#region 执行Sql语句,返回带分页功能的自定义dataset

///

/// 执行Sql语句,返回带分页功能的自定义dataset

///

/// Sql语句

/// 每页显示记录数

/// 当前页

/// 返回dataset表名

/// 返回DataSet

public DataSet GetDataSet(stringsql,int PageSize,int CurrPageIndex,string DataSetName)

{

DataSet ds=new DataSet();

Open();//打开数据连接

OracleDataAdapter adapter=new OracleDataAdapter(sql,con);

adapter.Fill(ds,PageSize * (CurrPageIndex -1), PageSize,DataSetName);

Close();//关闭数据库连接

return ds;

}

#endregion

#region 执行SQL语句，返回记录总数

///

/// 执行SQL语句，返回记录总数

///

/// sql语句

/// 返回记录总条数

public int GetRecordCount(stringsql)

{

int recordCount = 0;

Open();//打开数据连接

OracleCommand command = new OracleCommand(sql,con);

OracleDataReader dataReader =command.ExecuteReader();

while(dataReader.Read())

{

recordCount++;

}

dataReader.Close();

Close();//关闭数据库连接

return recordCount;

}

#endregion

#region 统计某表记录总数

///

/// 统计某表记录总数

///

/// 主键/索引键

/// 数据库.用户名.表名

/// 查询条件

/// 返回记录总数

public int GetRecordCount(stringkeyField, string tableName, string condition)

{

int RecordCount = 0;

string sql = "select count(" + keyField+ ") as count from " + tableName + " " + condition;

DataSet ds = GetDataSet(sql);

if (ds.Tables[0].Rows.Count > 0)

{

RecordCount=Convert.ToInt32(ds.Tables[0].Rows[0][0]);

}

ds.Clear();

ds.Dispose();

return RecordCount;

}

///

/// 统计某表记录总数

///

/// 可重复的字段

/// 数据库.用户名.表名

/// 查询条件

/// 字段是否主键

/// 返回记录总数

public int GetRecordCount(stringField, string tableName, string condition, bool flag)

{

int RecordCount = 0;

if (flag)

{

RecordCount = GetRecordCount(Field,tableName, condition);

}

else

{

string sql = "selectcount(distinct(" + Field + ")) as count from " + tableName +" " + condition;

DataSet ds = GetDataSet(sql);

if (ds.Tables[0].Rows.Count > 0)

{

RecordCount =Convert.ToInt32(ds.Tables[0].Rows[0][0]);

}

ds.Clear();

ds.Dispose();

}

return RecordCount;

}

#endregion

#region 统计某表分页总数

///

/// 统计某表分页总数

///

/// 主键/索引键

/// 表名

/// 查询条件

/// 页宽

/// 记录总数

/// 返回分页总数

public int GetPageCount(stringkeyField, string tableName, string condition, int pageSize, int RecordCount)

{

int PageCount = 0;

PageCount = (RecordCount % pageSize) > 0? (RecordCount / pageSize) + 1 : RecordCount / pageSize;

if (PageCount < 1) PageCount = 1;

return PageCount;

}

///

/// 统计某表分页总数

///

/// 主键/索引键

/// 表名

/// 查询条件

/// 页宽

/// 返回页面总数

public int GetPageCount(stringkeyField, string tableName, string condition, int pageSize, ref intRecordCount)

{

RecordCount = GetRecordCount(keyField,tableName, condition);

return GetPageCount(keyField, tableName, condition,pageSize, RecordCount);

}

///

/// 统计某表分页总数

///

/// 可重复的字段

/// 表名

/// 查询条件

/// 页宽

/// 是否主键

/// 返回页页总数

public int GetPageCount(stringField, string tableName, string condition, ref int RecordCount, int pageSize,bool flag)

{

RecordCount = GetRecordCount(Field,tableName, condition, flag);

return GetPageCount(Field, tableName,condition, pageSize, ref RecordCount);

}

#endregion

#region Sql分页函数

///

/// 构造分页查询SQL语句

///

/// 主键

/// 所有需要查询的字段(field1,field2...)

/// 库名.拥有者.表名

/// 查询条件1(where ...)

/// 排序条件2(order by ...)

/// 当前页号

/// 页宽

/// SQL语句

public string JoinPageSQL(stringKeyField, string FieldStr, string TableName, string Where, string Order, intCurrentPage, int PageSize)

{

string sql = null;

if (CurrentPage == 1)

{

sql = "select " + CurrentPage * PageSize + "" + FieldStr + " from " + TableName + " " + Where +" " + Order + " ";

}

else

{

sql = "select * from (";

sql += "select " + CurrentPage * PageSize + "" + FieldStr + " from " + TableName + " " + Where +" " + Order + ") a ";

sql += "where " + KeyField +" not in (";

sql += "select " + (CurrentPage - 1) * PageSize +" " + KeyField + " from " + TableName + " " +Where + " " + Order + ")";

}

return sql;

}

///

/// 构造分页查询SQL语句

///

/// 字段名(非主键)

/// 库名.拥有者.表名

/// 查询条件1(where ...)

/// 排序条件2(order by ...)

/// 当前页号

/// 页宽

/// SQL语句

public string JoinPageSQL(stringField, string TableName,string Where, string Order, int CurrentPage, intPageSize)

{

string sql = null;

if (CurrentPage == 1)

{

sql = "select rownum " +CurrentPage * PageSize + " " + Field + " from " + TableName+ " " + Where + " " + Order + " group by " +Field;

}

else

{

sql = "select * from (";

sql += "select rownum " +CurrentPage * PageSize + " " + Field + " from " + TableName+ " " + Where + " " + Order + " group by " +Field + " ) a ";

sql += "where " + Field + "not in (";

sql += "select rownum " +(CurrentPage - 1) * PageSize + " " + Field + " from " +TableName + " " + Where + " " + Order + " group by" + Field + ")";

}

return sql;

}

#endregion

#region 根据系统时间动态生成各种查询语句(现已经注释掉，以备以后使用)

// #region 根据查询时间的条件，动态生成查询语句

// ///

// /// 根据查询时间的条件，动态生成查询语句

// ///

// /// 开始时间

// /// 结束时间

// /// 单位

// /// 开始线损率

// /// 结束线损率

// /// 单位字段

// /// 线损率字段

// /// 表后缀

// /// SQL语句

// public string SQL(DateTimestarttime,DateTime endtime,string dw,float startxsl,float endxsl,stringdanwei,string xiansunlv,string tablehz)

// {

// string sql=null;

// //将输入的时间格式转换成固定的格式"yyyy-mm-dd"

// string zstarttime=starttime.GetDateTimeFormats('D')[1].ToString();

// string zendtime=endtime.GetDateTimeFormats('D')[1].ToString();

// string nTime=DateTime.Now.GetDateTimeFormats('D')[1].ToString();

// //取日期值的前六位，及年月值

// string sTime=zstarttime.Substring(0,4)+zstarttime.Substring(5,2);

// string eTime=zendtime.Substring(0,4)+zendtime.Substring(5,2);

// string nowTime=nTime.Substring(0,4)+nTime.Substring(5,2);

// //分别取日期的年和月

// int sy=Convert.ToInt32(zstarttime.Substring(0,4));

// int ey=Convert.ToInt32(zendtime.Substring(0,4));

// int sm=Convert.ToInt32(zstarttime.Substring(5,2));

// int em=Convert.ToInt32(zendtime.Substring(5,2));

// //相关变量定义

// int s;

// int e;

// int i;

// int j;

// int js;

// int nz;

// string x;

// //一，取当前表生成SQL语句

// if(sTime==nowTime&&eTime==nowTime)

// {

// sql="select * from"+tablehz+" "+"where"+""+danwei+"="+dw+" "+""+"and"+" "+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+"";

// }

// //二，取当前表和其他表生成SQL语句

// else if(sTime==nowTime&&eTime!=nowTime)

// {

// sql="select * from"+tablehz+" "+"where"+""+danwei+"="+dw+" "+""+"and"+" "+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// //如果年份相等

// if(sy==ey)

// {

// s=Convert.ToInt32(sTime);

// e=Convert.ToInt32(eTime);

// for(i=s+1;i

// {

// i=i++;

// sql+="select * from"+i.ToString()+'_'+tablehz+" "+"where"+""+danwei+"="+dw+" "+""+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// sql+="select * from"+e.ToString()+'_'+tablehz+" "+"where"+""+danwei+"="+dw+" "+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+"";

// }

// //结束年份大于开始年份

// else

// {

// //1，先循环到起始时间和起始时间的12月

// s=Convert.ToInt32(sTime);

// x=zstarttime.Substring(0,4)+"12";

// nz=Convert.ToInt32(x);

// for(i=s+1;i<=nz;i++)

// {

// i=i++;

// sql+="select * from "+i.ToString()+'_'+tablehz+""+"where"+" "+danwei+"="+dw+""+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// //2，循环两者相差年份

// for(i=sy+1;i

// {

// for(j=1;j<=12;j++)

// {

// if(j<10)

// {

// sql+="select * from"+i.ToString()+"0"+j.ToString()+'_'+tablehz+""+"where"+" "+danwei+"="+dw+" "+""+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// else

// {

// sql+="select * from"+i.ToString()+j.ToString()+'_'+tablehz+""+"where"+" "+danwei+"="+dw+""+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// //3，循环到结束的月份

// js=Convert.ToInt32(zendtime.Substring(0,4)+"00");

// for(i=js;i

// {

// i++;

// sql+="select * from"+i.ToString()+'_'+tablehz+" "+"where"+""+danwei+"="+dw+" "+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// sql+="select * from"+eTime.ToString()+'_'+tablehz+" "+"where"+""+danwei+"="+dw+" "+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+"";

// }

// //三，取其他表生成生成SQL语句

// else

// {

// //1，先循环到起始时间和起始时间的12月

// s=Convert.ToInt32(sTime);

// x=zstarttime.Substring(0,4)+"12";

// nz=Convert.ToInt32(x);

// for(i=s;i<=nz;i++)

// {

// i=i++;

// sql+="select * from"+i.ToString()+'_'+tablehz+" "+"where"+""+danwei+"="+dw+" "+""+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// //2，循环两者相差年份

// for(i=sy+1;i

// {

// for(j=1;j<=12;j++)

// {

// if(j<10)

// {

// sql+="select * from"+i.ToString()+"0"+j.ToString()+'_'+tablehz+""+"where"+" "+danwei+"="+dw+" "+""+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// else

// {

// sql+="select * from"+i.ToString()+j.ToString()+'_'+tablehz+""+"where"+" "+danwei+"="+dw+""+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// //3，循环到结束的月份

// js=Convert.ToInt32(zendtime.Substring(0,4)+"00");

// for(i=js;i

// {

// i++;

// sql+="select * from"+i.ToString()+'_'+tablehz+" "+"where"+""+danwei+"="+dw+" "+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+""+"union"+" ";

// }

// sql+="select * from"+eTime.ToString()+'_'+tablehz+" "+"where"+""+danwei+"="+dw+" "+" "+"and"+""+xiansunlv+">="+startxsl+""+"and"+" "+xiansunlv+"<="+endxsl+"";

// }

// return sql;

// }

// #endregion

// #region 根据查询时间的条件，动态生成查询语句

// ///

// /// 根据查询时间的条件，动态生成查询语句

// ///

// /// 开始时间

// /// 结束时间

// /// 查询字段

// /// 查询条件

// /// 表后缀

// /// SQL语句

// public string SQL(DateTimestarttime,DateTime endtime,string zhiduan,string tiaojiao,string tablehz)

// {

// string sql=null;

// //将输入的时间格式转换成固定的格式"yyyy-mm-dd"

// string zstarttime=starttime.GetDateTimeFormats('D')[1].ToString();

// string zendtime=endtime.GetDateTimeFormats('D')[1].ToString();

// string nTime=DateTime.Now.GetDateTimeFormats('D')[1].ToString();

// //取日期值的前六位，及年月值

// string sTime=zstarttime.Substring(0,4)+zstarttime.Substring(5,2);

// string eTime=zendtime.Substring(0,4)+zendtime.Substring(5,2);

// string nowTime=nTime.Substring(0,4)+nTime.Substring(5,2);

// //分别取日期的年和月

// int sy=Convert.ToInt32(zstarttime.Substring(0,4));

// int ey=Convert.ToInt32(zendtime.Substring(0,4));

// int sm=Convert.ToInt32(zstarttime.Substring(5,2));

// int em=Convert.ToInt32(zendtime.Substring(5,2));

// //相关变量定义

// int s;

// int e;

// int i;

// int j;

// int js;

// int nz;

// string x;

// //一，取当前表生成SQL语句

// if(sTime==nowTime&&eTime==nowTime)

// {

// sql="select"+" "+zhiduan+""+"from"+" "+tablehz+""+"where"+" "+tiaojiao+" ";

// }

// //二，取当前表和其他表生成SQL语句

// else if(sTime==nowTime&&eTime!=nowTime)

// {

// sql="select"+" "+zhiduan+""+"from"+" "+tablehz+""+"where"+" "+tiaojiao+""+"union"+" ";

// //如果年份相等

// if(sy==ey)

// {

// s=Convert.ToInt32(sTime);

// e=Convert.ToInt32(eTime);

// for(i=s+1;i

// {

// i=i++;

// sql+="select"+" "+zhiduan+""+"from"+" "+i.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+""+"union"+" ";

// }

// sql+="select"+" "+zhiduan+""+"from"+" "+e.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+" ";

// }

// //结束年份大于开始年份

// else

// {

// //1，先循环到起始时间和起始时间的12月

// s=Convert.ToInt32(sTime);

// x=zstarttime.Substring(0,4)+"12";

// nz=Convert.ToInt32(x);

// for(i=s+1;i<=nz;i++)

// {

// i=i++;

// sql+="select"+" "+zhiduan+""+"from"+" "+i.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+""+"union"+" ";

// }

// //2，循环两者相差年份

// for(i=sy+1;i

// {

// for(j=1;j<=12;j++)

// {

// if(j<10)

// {

// sql+="select"+" "+zhiduan+""+"from"+""+i.ToString()+"0"+j.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+""+"union"+" ";

// }

// else

// {

// sql+="select"+" "+zhiduan+""+"from"+""+i.ToString()+j.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+" "+"union"+"";

// }

// //3，循环到结束的月份

// js=Convert.ToInt32(zendtime.Substring(0,4)+"00");

// for(i=js;i

// {

// i++;

// sql+="select"+" "+zhiduan+""+"from"+" "+i.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+""+"union"+" ";

// }

// sql+="select"+" "+zhiduan+""+"from"+" "+eTime.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+" ";

// }

// //三，取其他表生成生成SQL语句

// else

// {

// //1，先循环到起始时间和起始时间的12月

// s=Convert.ToInt32(sTime);

// x=zstarttime.Substring(0,4)+"12";

// nz=Convert.ToInt32(x);

// for(i=s;i<=nz;i++)

// {

// i=i++;

// sql+="select"+" "+zhiduan+""+"from"+" "+i.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+""+"union"+" ";

// }

// //2，循环两者相差年份

// for(i=sy+1;i

// {

// for(j=1;j<=12;j++)

// {

// if(j<10)

// {

// sql+="select"+" "+zhiduan+""+"from"+""+i.ToString()+"0"+j.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+" "+"union"+"";

// }

// else

// {

// sql+="select"+" "+zhiduan+""+"from"+""+i.ToString()+j.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+" "+"union"+"";

// }

// //3，循环到结束的月份

// js=Convert.ToInt32(zendtime.Substring(0,4)+"00");

// for(i=js;i

// {

// i++;

// sql+="select"+" "+zhiduan+""+"from"+" "+i.ToString()+'_'+tablehz+""+"where"+" "+tiaojiao+""+"union"+" ";

// }

// sql+="select"+" "+zhiduan+" "+"from"+""+eTime.ToString()+'_'+tablehz+" "+"where"+""+tiaojiao+" ";

// }

// return sql;

// }

// #endregion

玖、另一个C#操作Oracle数据库的通用类

c#操作oracle的通用类

2009-12-28 来自：百度博客字体大小：【大中小】

摘要：本文为一个c#操作oracle的通用类

using System;

using System.Data;

using System.Data.OracleClient;

using System.Collections;

using System.Reflection;

namespace MyOraComm

{

///

/// ConnDbForOracle 的摘要说明。

///

public class ConnForOracle

{

protected OracleConnection Connection;

private string connectionString;

public ConnForOracle()

{

string connStr;

connStr =

System.Configuration.ConfigurationSettings.

AppSettings["connStr"].ToString();

connectionString = connStr;

Connection = new OracleConnection(connectionString);

}

#region 带参数的构造函数

///

/// 带参数的构造函数

///

/// 数据库联接字符串

public ConnForOracle(string ConnString)

{

string connStr;

connStr =

System.Configuration.ConfigurationSettings.

AppSettings[ConnString].ToString();

Connection = new OracleConnection(connStr);

}

#endregion

#region 打开数据库

///

/// 打开数据库

///

public void OpenConn()

{

if(this.Connection.State!=ConnectionState.Open)

this.Connection.Open();

}

#endregion

#region 关闭数据库联接

///

/// 关闭数据库联接

///

public void CloseConn()

{

if(Connection.State==ConnectionState.Open)

Connection.Close();

}

#endregion

#region 执行SQL语句，返回数据到DataSet中

///

/// 执行SQL语句，返回数据到DataSet中

///

/// sql语句

/// 自定义返回的DataSet表名

/// 返回DataSet

public DataSet ReturnDataSet(string sql,string DataSetName)

{

DataSet dataSet=new DataSet();

OpenConn();

OracleDataAdapter OraDA=new OracleDataAdapter(sql,Connection);

OraDA.Fill(dataSet,DataSetName);

// CloseConn();

return dataSet;

}

#endregion

#region 执行Sql语句,返回带分页功能的dataset

///

/// 执行Sql语句,返回带分页功能的dataset

///

/// Sql语句

/// 每页显示记录数

/// <当前页/param>

/// 返回dataset表名

/// 返回DataSet

public DataSet ReturnDataSet(string sql,int PageSize,

int CurrPageIndex,string DataSetName)

{

DataSet dataSet=new DataSet();

OpenConn();

OracleDataAdapter OraDA=

new OracleDataAdapter(sql,Connection);

OraDA.Fill(dataSet,PageSize * (CurrPageIndex - 1),

PageSize,DataSetName);

// CloseConn();

return dataSet;

}

#endregion

#region 执行SQL语句，返回 DataReader,用之前一定要先.read()打开,然后才能读到数据

///

/// 执行SQL语句，返回 DataReader,用之前一定要先.read()打开,然后才能读到数据

///

/// sql语句

/// 返回一个OracleDataReader

public OracleDataReader ReturnDataReader(String sql)

{

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

returncommand.ExecuteReader(System.Data.CommandBehavior.CloseConnection);

}

#endregion

#region 执行SQL语句，返回记录总数数

///

/// 执行SQL语句，返回记录总数数

///

/// sql语句

/// 返回记录总条数

public int GetRecordCount(string sql)

{

int recordCount = 0;

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

OracleDataReader dataReader = command.ExecuteReader();

while(dataReader.Read())

{

recordCount++;

}

dataReader.Close();

// CloseConn();

return recordCount;

}

#endregion

#region 取当前序列,条件为seq.nextval或seq.currval

///

/// 取当前序列

///

public decimal GetSeq(string seqstr)

{

decimal seqnum = 0;

string sql="select "+seqstr+" from dual";

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

OracleDataReader dataReader = command.ExecuteReader();

if(dataReader.Read())

{

seqnum=decimal.Parse(dataReader[0].ToString());

}

dataReader.Close();

// CloseConn();

return seqnum;

}

#endregion

#region 执行SQL语句,返回所影响的行数

///

/// 执行SQL语句,返回所影响的行数

///

public int ExecuteSQL(string sql)

{

int Cmd=0;

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

try

{

Cmd =command.ExecuteNonQuery();

}

catch

{

}

finally

{

// CloseConn();

}

return Cmd;

}

#endregion

//　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

//　用hashTable对数据库进行insert,update,del操作,注意此时只能

// 用默认的数据库连接"connstr"

//　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

#region 根据表名及哈稀表自动插入数据库用法：Insert("test",ht)

public int Insert(string TableName,Hashtable ht)

{

OracleParameter[] Parms=new OracleParameter[ht.Count];

IDictionaryEnumerator et = ht.GetEnumerator();

DataTable dt=GetTabType(TableName);

System.Data.OracleClient.OracleType otype;

int size=0;

int i=0;

while ( et.MoveNext() ) // 作哈希表循环

{

GetoType(et.Key.ToString().ToUpper(),dt,out otype,out size);

System.Data.OracleClient.OracleParameter op=MakeParam(":"+

et.Key.ToString(),otype,size,et.Value.ToString());

Parms[i]=op; // 添加SqlParameter对象

i=i+1;

}

string str_Sql=GetInsertSqlbyHt(TableName,ht); // 获得插入sql语句

int val=ExecuteNonQuery(str_Sql,Parms);

return val;

}

#endregion

#region 根据相关条件对数据库进行更新操作用法：Update("test","Id=:Id",ht);

public int Update(string TableName,string ht_Where, Hashtable ht)

{

OracleParameter[] Parms=new OracleParameter[ht.Count];

IDictionaryEnumerator et = ht.GetEnumerator();

DataTable dt=GetTabType(TableName);

System.Data.OracleClient.OracleType otype;

int size=0;

int i=0;

// 作哈希表循环

while ( et.MoveNext() )

{

GetoType(et.Key.ToString().ToUpper(),dt,out otype,out size);

System.Data.OracleClient.OracleParameter op=

MakeParam(":"+et.Key.ToString(),otype,size,et.Value.ToString());

Parms[i]=op; // 添加SqlParameter对象

i=i+1;

}

string str_Sql=GetUpdateSqlbyHt(TableName,ht_Where,ht); // 获得插入sql语句

int val=ExecuteNonQuery(str_Sql,Parms);

return val;

}

#endregion

#region del操作

//,注意此处条件个数与hash里参数个数应该一致

//用法：Del("test","Id=:Id",ht)

public int Del(stringTableName,string ht_Where,Hashtable ht)

{

OracleParameter[] Parms=new OracleParameter[ht.Count];

IDictionaryEnumerator et = ht.GetEnumerator();

DataTable dt=GetTabType(TableName);

System.Data.OracleClient.OracleType otype;

int i=0;

int size=0;

// 作哈希表循环

while ( et.MoveNext() )

{

GetoType(et.Key.ToString().ToUpper(),dt,out otype,out size);

System.Data.OracleClient.OracleParameter op=

MakeParam(":"+et.Key.ToString(),et.Value.ToString());

Parms[i]=op; // 添加SqlParameter对象

i=i+1;

}

string str_Sql=GetDelSqlbyHt(TableName,ht_Where,ht); // 获得删除sql语句

int val=ExecuteNonQuery(str_Sql,Parms);

return val;

}

#endregion

//　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

//　＝＝＝＝＝＝＝＝上面三个操作的内部调用函数＝＝＝＝＝＝＝

//　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

#region 根据哈稀表及表名自动生成相应insert语句(参数类型的)

///

/// 根据哈稀表及表名自动生成相应insert语句

///

/// 要插入的表名

/// 哈稀表

/// 返回sql语句

public static string GetInsertSqlbyHt(string TableName,Hashtable ht)

{

string str_Sql="";

int i=0;

int ht_Count=ht.Count; // 哈希表个数

IDictionaryEnumerator myEnumerator = ht.GetEnumerator();

string before="";

string behide="";

while ( myEnumerator.MoveNext() )

{

if (i==0)

{

before="("+myEnumerator.Key;

}

else if (i+1==ht_Count)

{

before=before+","+myEnumerator.Key+")";

}

else

{

before=before+","+myEnumerator.Key;

}

i=i+1;

}

behide="Values"+before.Replace(",",",:").Replace("(","(:");

str_Sql="Insert into "+TableName+before+behide;

return str_Sql;

}

#endregion

#region 根据表名，where条件，哈稀表自动生成更新语句(参数类型的)

public static string GetUpdateSqlbyHt(string Table,

string ht_Where,Hashtable ht)

{

string str_Sql="";

int i=0;

int ht_Count=ht.Count; // 哈希表个数

IDictionaryEnumerator myEnumerator = ht.GetEnumerator();

while ( myEnumerator.MoveNext() )

{

if (i==0)

{

if (ht_Where.ToString().ToLower().IndexOf((myEnumerator.Key+

"=:"+myEnumerator.Key).ToLower())==-1)

{

str_Sql=myEnumerator.Key+"=:"+myEnumerator.Key;

}

else

{

if (ht_Where.ToString().ToLower().IndexOf((":"+

myEnumerator.Key+" ").ToLower())==-1)

{

str_Sql=str_Sql+","+myEnumerator.Key+"=:"+myEnumerator.Key;

}

i=i+1;

}

if (ht_Where==null || ht_Where.Replace("","")=="") // 更新时候没有条件

{

str_Sql="update "+Table+" set "+str_Sql;

}

else

{

str_Sql="update "+Table+" set "+str_Sql+" where"+ht_Where;

}

str_Sql=str_Sql.Replace("set ,","set").Replace("update ,","update ");

return str_Sql;

}

#endregion

#region 根据表名，where条件，哈稀表自动生成del语句(参数类型的)

public static string GetDelSqlbyHt(string Table,

string ht_Where,Hashtable ht)

{

string str_Sql="";

int i=0;

int ht_Count=ht.Count; // 哈希表个数

IDictionaryEnumerator myEnumerator = ht.GetEnumerator();

while ( myEnumerator.MoveNext() )

{

if (i==0)

{

if (ht_Where.ToString().ToLower().IndexOf((myEnumerator.Key+

"=:"+myEnumerator.Key).ToLower())==-1)

{

str_Sql=myEnumerator.Key+"=:"+myEnumerator.Key;

}

else

{

if (ht_Where.ToString().ToLower().IndexOf((":"+

myEnumerator.Key+" ").ToLower())==-1)

{

str_Sql=str_Sql+","+myEnumerator.Key+"=:"+myEnumerator.Key;

}

i=i+1;

}

if (ht_Where==null || ht_Where.Replace("","")=="") // 更新时候没有条件

{

str_Sql="Delete "+Table;

}

else

{

str_Sql="Delete "+Table+" where "+ht_Where;

}

return str_Sql;

}

#endregion

#region 生成oracle参数

///

/// 生成oracle参数

///

/// 字段名

/// 数据类型

/// 数据大小

/// 值

///

public static OracleParameterMakeParam(string ParamName,

System.Data.OracleClient.OracleType otype,int size,Object Value)

{

OracleParameter para=new OracleParameter(ParamName,Value);

para.OracleType=otype;

para.Size=size;

return para;

}

#endregion

#region 生成oracle参数

public static OracleParameter MakeParam(string ParamName,string Value)

{

return new OracleParameter(ParamName, Value);

}

#endregion

#region 根据表结构字段的类型和长度拼装oracle sql语句参数

public static void GetoType(string key,DataTable dt,

out System.Data.OracleClient.OracleType otype,out int size)

{

DataView dv=dt.DefaultView;

dv.RowFilter="column_name='"+key+"'";

string fType=dv[0]["data_type"].ToString().ToUpper();

switch (fType)

{

case "DATE":

otype= OracleType.DateTime;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "CHAR":

otype= OracleType.Char;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "LONG":

otype= OracleType.Double;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "NVARCHAR2":

otype= OracleType.NVarChar;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "VARCHAR2":

otype= OracleType.NVarChar;

size=int.Parse(dv[0]["data_length"].ToString());

break;

default:

otype= OracleType.NVarChar;

size=100;

break;

}

#endregion

#region动态取表里字段的类型和长度,此处没有动态用到connstr,是默认的！by/文少

public System.Data.DataTable GetTabType(string tabnale)

{

string sql="select column_name,data_type,data_length "+

"from all_tab_columns wheretable_name='"+tabnale.ToUpper()+"'";

OpenConn();

return (ReturnDataSet(sql,"dv")).Tables[0];

}

#endregion

#region 执行sql语句

public int ExecuteNonQuery(string cmdText, params OracleParameter[] cmdParms)

{

OracleCommand cmd = new OracleCommand();

OpenConn();

cmd.Connection=Connection;

cmd.CommandText = cmdText;

if (cmdParms != null)

{

foreach (OracleParameter parm in cmdParms)

cmd.Parameters.Add(parm);

}

int val = cmd.ExecuteNonQuery();

cmd.Parameters.Clear();

// conn.CloseConn();

return val;

}

#endregion

//　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

//　＝＝＝＝＝＝＝＝＝内部调用函数完＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

//　＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

}

拾、C# Oracle连接操作类

C# Oracle连接操作类

标签：数据库连接类 Oracle 　更新时间：2013-11-18

using System;

using System.Data;

using System.Data.OracleClient;

using System.Collections;

using System.Reflection;

namespace MyOraComm

{

///ConnDbForOracle 的摘要说明。

public class ConnForOracle

{

protected OracleConnection Connection;

private string connectionString;

public ConnForOracle()

{

string connStr;

connStr = System.Configuration.ConfigurationSettings.AppSettings["connStr"].ToString();

connectionString = connStr;

Connection = new OracleConnection(connectionString);

}

#region 带参数的构造函数

/// 带参数的构造函数

/// 数据库联接字符串

public ConnForOracle(string ConnString)

{

string connStr;

connStr =System.Configuration.ConfigurationSettings.AppSettings[ConnString].ToString();

Connection = new OracleConnection(connStr);

}

#endregion

#region 打开数据库

/// 打开数据库

public void OpenConn()

{

if(this.Connection.State!=ConnectionState.Open)

this.Connection.Open();

}

#endregion

#region 关闭数据库联接

/// 关闭数据库联接

public void CloseConn()

{

if(Connection.State==ConnectionState.Open)

Connection.Close();

}

#endregion

#region 执行SQL语句，返回数据到DataSet中

/// 执行SQL语句，返回数据到DataSet中

/// sql语句

/// 自定义返回的DataSet表名

/// 返回DataSet

public DataSet ReturnDataSet(string sql,string DataSetName)

{

DataSet dataSet=new DataSet();

OpenConn();

OracleDataAdapter OraDA=new OracleDataAdapter(sql,Connection);

OraDA.Fill(dataSet,DataSetName);

// CloseConn();

return dataSet;

}

#endregion

#region 执行Sql语句,返回带分页功能的dataset

/// 执行Sql语句,返回带分页功能的dataset

/// Sql语句

/// 每页显示记录数

/// <当前页/param>

/// 返回dataset表名

/// 返回DataSet

public DataSet ReturnDataSet(string sql,int PageSize,intCurrPageIndex,string DataSetName)

{

DataSet dataSet=new DataSet();

OpenConn();

OracleDataAdapter OraDA=new OracleDataAdapter(sql,Connection);

OraDA.Fill(dataSet,PageSize * (CurrPageIndex - 1),PageSize,DataSetName);

// CloseConn();

return dataSet;

}

#endregion

#region 执行SQL语句，返回 DataReader,用之前一定要先.read()打开,然后才能读到数据

/// 执行SQL语句，返回 DataReader,用之前一定要先.read()打开,然后才能读到数据

/// sql语句

/// 返回一个OracleDataReader

public OracleDataReader ReturnDataReader(String sql)

{

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

returncommand.ExecuteReader(System.Data.CommandBehavior.CloseConnection);

}

#endregion

#region 执行SQL语句，返回记录总数数

/// 执行SQL语句，返回记录总数数

/// sql语句

/// 返回记录总条数

public int GetRecordCount(string sql)

{

int recordCount = 0;

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

OracleDataReader dataReader = command.ExecuteReader();

while(dataReader.Read())

{

recordCount++;

}

dataReader.Close();

//CloseConn();

return recordCount;

}

#endregion

#region 取当前序列,条件为seq.nextval或seq.currval

///

/// 取当前序列

public decimal GetSeq(string seqstr)

{

decimal seqnum = 0;

string sql="select "+seqstr+" from dual";

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

OracleDataReader dataReader = command.ExecuteReader();

if(dataReader.Read())

{

seqnum=decimal.Parse(dataReader[0].ToString());

}

dataReader.Close();

// CloseConn();

return seqnum;

}

#endregion

#region 执行SQL语句,返回所影响的行数

/// 执行SQL语句,返回所影响的行数

public int ExecuteSQL(string sql)

{

int Cmd=0;

OpenConn();

OracleCommand command = new OracleCommand(sql,Connection);

try

{

Cmd =command.ExecuteNonQuery();

}

catch

{

}

finally

{

//CloseConn();

}

return Cmd;

}

#endregion

//＝＝用hashTable对数据库进行insert,update,del操作,注意此时只能用默认的数据库连接"connstr"

#region 根据表名及哈稀表自动插入数据库用法：Insert("test",ht)

public int Insert(string TableName,Hashtable ht)

{

OracleParameter[] Parms=new OracleParameter[ht.Count];

IDictionaryEnumerator et = ht.GetEnumerator();

DataTable dt=GetTabType(TableName);

System.Data.OracleClient.OracleType otype;

int size=0;

int i=0;

while ( et.MoveNext() ) // 作哈希表循环

{

GetoType(et.Key.ToString().ToUpper(),dt,out otype,out size);

System.Data.OracleClient.OracleParameterop=MakeParam(":"+et.Key.ToString(),otype,size,et.Value.ToString());

Parms[i]=op; // 添加SqlParameter对象

i=i+1;

}

string str_Sql=GetInsertSqlbyHt(TableName,ht); // 获得插入sql语句

int val=ExecuteNonQuery(str_Sql,Parms);

return val;

}

#endregion

#region 根据相关条件对数据库进行更新操作用法：Update("test","Id=:Id",ht);

public int Update(string TableName,string ht_Where, Hashtable ht)

{

OracleParameter[] Parms=new OracleParameter[ht.Count];

IDictionaryEnumerator et = ht.GetEnumerator();

DataTable dt=GetTabType(TableName);

System.Data.OracleClient.OracleType otype;

int size=0;

int i=0;

// 作哈希表循环

while ( et.MoveNext() )

{

GetoType(et.Key.ToString().ToUpper(),dt,out otype,out size);

System.Data.OracleClient.OracleParameterop=MakeParam(":"+et.Key.ToString(),otype,size,et.Value.ToString());

Parms[i]=op; // 添加SqlParameter对象

i=i+1;

}

string str_Sql=GetUpdateSqlbyHt(TableName,ht_Where,ht); // 获得插入sql语句

int val=ExecuteNonQuery(str_Sql,Parms);

return val;

}

#endregion

#region del操作,注意此处条件个数与hash里参数个数应该一致用法：Del("test","Id=:Id",ht)

public int Del(stringTableName,string ht_Where,Hashtable ht)

{

OracleParameter[] Parms=new OracleParameter[ht.Count];

IDictionaryEnumerator et = ht.GetEnumerator();

DataTable dt=GetTabType(TableName);

System.Data.OracleClient.OracleType otype;

int i=0;

int size=0;

// 作哈希表循环

while ( et.MoveNext() )

{

GetoType(et.Key.ToString().ToUpper(),dt,out otype,out size);

System.Data.OracleClient.OracleParameterop=MakeParam(":"+et.Key.ToString(),et.Value.ToString());

Parms[i]=op; // 添加SqlParameter对象

i=i+1;

}

string str_Sql=GetDelSqlbyHt(TableName,ht_Where,ht); // 获得删除sql语句

int val=ExecuteNonQuery(str_Sql,Parms);

return val;

}

#endregion

//　＝＝＝＝＝＝＝＝上面三个操作的内部调用函数＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

#region 根据哈稀表及表名自动生成相应insert语句(参数类型的)

/// 根据哈稀表及表名自动生成相应insert语句

/// 要插入的表名

/// 哈稀表

/// 返回sql语句

publicstatic string GetInsertSqlbyHt(string TableName,Hashtable ht)

{

string str_Sql="";

int i=0;

int ht_Count=ht.Count; // 哈希表个数

IDictionaryEnumerator myEnumerator = ht.GetEnumerator();

string before="";

string behide="";

while ( myEnumerator.MoveNext() )

{

if (i==0)

{

before="("+myEnumerator.Key;

}

else if (i+1==ht_Count)

{

before=before+","+myEnumerator.Key+")";

}

else

{

before=before+","+myEnumerator.Key;

}

i=i+1;

}

behide="Values"+before.Replace(",",",:").Replace("(","(:");

str_Sql="Insert into "+TableName+before+behide;

return str_Sql;

}

#endregion

#region 根据表名，where条件，哈稀表自动生成更新语句(参数类型的)

public static string GetUpdateSqlbyHt(string Table,stringht_Where,Hashtable ht)

{

string str_Sql="";

int i=0;

int ht_Count=ht.Count; // 哈希表个数

IDictionaryEnumerator myEnumerator = ht.GetEnumerator();

while ( myEnumerator.MoveNext() )

{

if (i==0)

{

if(ht_Where.ToString().ToLower().IndexOf((myEnumerator.Key+"=:"+myEnumerator.Key).ToLower())==-1)

{

str_Sql=myEnumerator.Key+"=:"+myEnumerator.Key;

}

else

{

if (ht_Where.ToString().ToLower().IndexOf((":"+myEnumerator.Key+"").ToLower())==-1)

{

str_Sql=str_Sql+","+myEnumerator.Key+"=:"+myEnumerator.Key;

}

i=i+1;

}

if (ht_Where==null || ht_Where.Replace("","")=="") // 更新时候没有条件

{

str_Sql="update "+Table+" set "+str_Sql;

}

else

{

str_Sql="update "+Table+" set "+str_Sql+" where"+ht_Where;

}

str_Sql=str_Sql.Replace("set ,","set").Replace("update ,","update ");

return str_Sql;

}

#endregion

#region 根据表名，where条件，哈稀表自动生成del语句(参数类型的)

publicstatic string GetDelSqlbyHt(string Table,string ht_Where,Hashtable ht)

{

string str_Sql="";

int i=0;

int ht_Count=ht.Count; // 哈希表个数

IDictionaryEnumerator myEnumerator = ht.GetEnumerator();

while ( myEnumerator.MoveNext() )

{

if (i==0)

{

if(ht_Where.ToString().ToLower().IndexOf((myEnumerator.Key+"=:"+myEnumerator.Key).ToLower())==-1)

{

str_Sql=myEnumerator.Key+"=:"+myEnumerator.Key;

}

else

{

if (ht_Where.ToString().ToLower().IndexOf((":"+myEnumerator.Key+"").ToLower())==-1)

{

str_Sql=str_Sql+","+myEnumerator.Key+"=:"+myEnumerator.Key;

}

i=i+1;

}

if (ht_Where==null || ht_Where.Replace("","")=="") // 更新时候没有条件

{

str_Sql="Delete "+Table;

}

else

{

str_Sql="Delete "+Table+" where "+ht_Where;

}

return str_Sql;

}

#endregion

#region 生成oracle参数

///

/// 生成oracle参数

/// 字段名

/// 数据类型

/// 数据大小

/// 值

public static OracleParameter MakeParam(stringParamName,System.Data.OracleClient.OracleType otype,int size,Object Value)

{

OracleParameter para=new OracleParameter(ParamName,Value);

para.OracleType=otype;

para.Size=size;

return para;

}

#endregion

#region生成oracle参数

public static OracleParameter MakeParam(string ParamName,string Value)

{

return new OracleParameter(ParamName, Value);

}

#endregion

#region 根据表结构字段的类型和长度拼装oracle sql语句参数

public static void GetoType(string key,DataTable dt,outSystem.Data.OracleClient.OracleType otype,out int size)

{

DataView dv=dt.DefaultView;

dv.RowFilter="column_name='"+key+"'";

string fType=dv[0]["data_type"].ToString().ToUpper();

switch (fType)

{

case "DATE":

otype= OracleType.DateTime;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "CHAR":

otype= OracleType.Char;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "LONG":

otype= OracleType.Double;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "NVARCHAR2":

otype= OracleType.NVarChar;

size=int.Parse(dv[0]["data_length"].ToString());

break;

case "VARCHAR2":

otype= OracleType.NVarChar;

size=int.Parse(dv[0]["data_length"].ToString());

break;

default:

otype= OracleType.NVarChar;

size=100;

break;

}

#endregion

#region动态取表里字段的类型和长度,此处没有动态用到connstr,是默认的！by/文少

public System.Data.DataTable GetTabType(string tabnale)

{

string sql="select column_name,data_type,data_length from all_tab_columns wheretable_name='"+tabnale.ToUpper()+"'";

OpenConn();

return (ReturnDataSet(sql,"dv")).Tables[0];

}

#endregion

#region 执行sql语句

public int ExecuteNonQuery(string cmdText, params OracleParameter[]cmdParms)

{

OracleCommand cmd = new OracleCommand();

OpenConn();

cmd.Connection=Connection;

cmd.CommandText = cmdText;

if (cmdParms != null)

{

foreach (OracleParameter parm in cmdParms)

cmd.Parameters.Add(parm);

}

int val = cmd.ExecuteNonQuery();

cmd.Parameters.Clear();

//conn.CloseConn();

return val;

}

#endregion

}

C# Oracle数据库连接及操作

壹、ORACLE817安装（服务器端/客户端）

贰、ORACLE817配置（服务器端）

叁、ORACLE817配置（客户端）

肆、安装的oracle 8i怎么全部卸载

伍、Oracle数据库体系结构

陆、ORACLE数据类型

柒、c#通过oledb连接Oracle

捌、一个C#操作Oracle的通用类

玖、另一个C#操作Oracle数据库的通用类

拾、C# Oracle连接 操作类

壹、ORACLE817安装（服务器端/客户端）

贰、ORACLE817配置（服务器端）

叁、ORACLE817配置（客户端）

肆、安装的oracle 8i怎么全部卸载

伍、Oracle数据库体系结构

陆、ORACLE数据类型

柒、c#通过oledb连接Oracle

捌、一个C#操作Oracle的通用类

玖、另一个C#操作Oracle数据库的通用类

拾、C# Oracle连接 操作类

你可能感兴趣的:(数据库)

拾、C# Oracle连接操作类

拾、C# Oracle连接操作类