OCI编程高级篇（二十） 使用连接池的例子

最新推荐文章于 2024-09-06 14:12:06 发布
最新推荐文章于 2024-09-06 14:12:06 发布
阅读量239 收藏
点赞数 2
文章标签： 数据库 oracle 数据库开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tomcoding/article/details/141905380
版权

这一节我们用代码实现一个实际的例子，来演示连接池的用法。例子中我们仅使用单线程来演示用法，例子的步骤如下。

1. 创建一个OCI环境，分配错误句柄。

2. 创建一个连接池。

3. 从连接池中获取一个会话。

4. 通过这个会话从数据库中查询一个数字，SQL语句为select 10 from dual。

5. 释放会话。

6. 销毁连接池。

7. 释放OCI环境。

例子代码如下，关键处有详细注释。

#include "stdio.h"
#include "stdlib.h"
#include "stdint.h"
#include "memory.h"
#include "string.h"
#include "time.h"
#include "errno.h"

#include "oci.h"


/* global variable defination */
OCIEnv          *envhp  = NULL;         /* env handle */
OCIError        *errhp  = NULL;         /* error handle */
OCISvcCtx       *svchp  = NULL;         /* service context handle */
OCICPool        *poolhp = NULL;         /* connection pool handle */
OCIAuthInfo     *authp  = NULL;         /* authentication information handle */
OCIStmt         *stmthp = NULL;         /* statement handle */

text            errbuf[512];            /* error message text */

struct {
    char        uname[32];              /* 认证用户名称 */
    char        upwd[32];               /* 认证用户密码 */
} inputs;

static void usage(const char *prg)
{
    fprintf(stderr,
        "Usage: %s user/password\n\n"
        "  user      oracle user\n"
        "  password  user password\n"
        , prg
    );
}

/* 解析命令行中的认证用户和密码 */
static int parse_inputs(int argc, char *argv[])
{
    char        *p;

    if (argc < 2) {
      usage(argv[0]);
      return (-1);
    }

    if ((p=strchr(argv[1], '/')) == NULL) {
      usage(argv[0]);
      return (-1);
    }

    *p++ = '\0';
    memset(&inputs, 0, sizeof(inputs));
    strncpy(inputs.uname, argv[1], 31);
    strncpy(inputs.upwd, p, 31);

    return (0);
}

static char ora_env[][16] =
{
  "ORACLE_HOME",
  "ORACLE_SID",
  ""
};

/* 检查Oracle运行的环境变量 */
static int check_ora_env(void)
{
    int         i;

    for (i=0; ora_env[i][0]; i++) {
        if (getenv(ora_env[i]) == NULL) {
            fprintf(stderr, "env %s not set.\n", ora_env[i]);
            return (-1);
        }
    }

    return (0);
}

/* 创建连接池函数 */
static int create_connection_pool(void)
{
    sword       rc;
    sb4         ec;
    ub4         conn_min;
    ub4         conn_max;
    ub4         conn_inc;
    sb4         pool_name_len;
    char        *pool_name;

    /* 创建环境句柄 */
    rc = OCIEnvCreate(
        &envhp,                 /* envhpp */
        OCI_DEFAULT,            /* mode */
        (void *)NULL,           /* ctxp */
        NULL,
        NULL,
        NULL,
        (size_t)0,
        (void **)NULL
    );

    if (rc != OCI_SUCCESS) {
        fprintf(stderr, "OCIEnvCreate() - allocate OCI env handle error !\n");
        return (-1);
    }

    /* 分配错误句柄 */
    rc = OCIHandleAlloc(
        (void *)envhp,
        (void **)&errhp,
        OCI_HTYPE_ERROR,
        0,
        (void **)NULL
    );

    if (rc != OCI_SUCCESS) {
        fprintf(stderr, "OCIHandleAlloc() - allocate OCI error handle error !\n");
        return (-1);
    }

    /* 分配连接池句柄 */
    rc = OCIHandleAlloc(
        (void *)envhp,
        (void **)&poolhp,
        OCI_HTYPE_CPOOL,
        (size_t)0,
        (void **)NULL
    );

    if (rc != OCI_SUCCESS) {
        fprintf(stderr, "OCIHandleAlloc() - allocate connection pool handle error !\n");
        return (-1);
    }

    /* 创建连接池，初始连接数为2，最大连接数为5，每次增长1个连接 */
    conn_min = 2;
    conn_max = 5;
    conn_inc = 1;
    rc = OCIConnectionPoolCreate(
        envhp, errhp, poolhp,
        (OraText **)&pool_name, &pool_name_len,
        (const OraText *)"", 0,
        (ub4)conn_min, (ub4)conn_max, (ub4)conn_inc,
        (OraText *)inputs.uname, strlen(inputs.uname),
        (OraText *)inputs.upwd, strlen(inputs.upwd),
        OCI_DEFAULT
    );

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCIConnectionPoolCreate() - [%d] %s\n", ec, errbuf);
        return (-1);
    }

    /* 显示一下连接池的名称 */
    fprintf(stdout, "connection pool name: [%d]%s\n", pool_name_len, pool_name);

    return (0);
}

/* 销毁连接池 */
static int destroy_connection_pool(void)
{
    sword       rc;
    sb4         ec;

    /* 销毁连接池 */
    if (poolhp != NULL) {
        rc = OCIConnectionPoolDestroy(poolhp, errhp, OCI_DEFAULT);

        if (rc != OCI_SUCCESS) {
            OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
            fprintf(stderr, "OCIConnectionPoolDestroy() - [%d] %s\n", ec, errbuf);
            return (-1);
        }

        /* 释放连接池句柄 */
        rc = OCIHandleFree((void *)poolhp, OCI_HTYPE_CPOOL);

        if (rc != OCI_SUCCESS) {
            fprintf(stderr, "OCIHandleFree() - free connection pool handle error !\n");
            return (-1);
        }
    }

    /* 释放错误句柄 */
    if (errhp != NULL) {
        rc = OCIHandleFree(
            errhp,
            OCI_HTYPE_ERROR
        );

        if (rc != OCI_SUCCESS) {
            fprintf(stderr, "OCIHandleFree() - free error handle error !\n");
            return (-1);
        }
    }

    /* 释放环境句柄 */
    if (envhp != NULL) {
        rc = OCIHandleFree(
            envhp,
            OCI_HTYPE_ENV
        );

        if (rc != OCI_SUCCESS) {
            fprintf(stderr, "OCIHandleFree() - free env handle error !\n");
            return (-1);
        }
    }

    return (0);
}

/* 从数据库中查询数值 */
static int query_from_dual(void)
{
    sword       rc;
    sb4         ec;
    int         slen;
    ub4         u4;
    char        sqltxt[1024];
    OCIDefine   *defp;

    /* 分配认证信息句柄 */
    rc = OCIHandleAlloc(
        (void *)envhp,
        (void **)&authp,
        OCI_HTYPE_AUTHINFO,
        (size_t)0,
        (void **)NULL
    );

    if (rc != OCI_SUCCESS) {
        fprintf(stderr, "OCIHandleAlloc() - allocate authentication handle error !\n");
        return (-1);
    }

    /* 设置认证用户名称 */
    rc = OCIAttrSet(
        (void *)authp,
        OCI_HTYPE_AUTHINFO,
        (dvoid *)inputs.uname,
        strlen(inputs.uname),
        OCI_ATTR_USERNAME,
        errhp
    );

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "Set User Attribute - [%d] %s\n", ec, errbuf);
        return (-1);
    }

    /* 设置认证用户密码 */
    rc = OCIAttrSet(
        (void *)authp,
        OCI_HTYPE_AUTHINFO,
        (void *)inputs.upwd,
        strlen(inputs.upwd),
        OCI_ATTR_PASSWORD,
        errhp
    );

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "Set Password Attribute - [%d] %s\n", ec, errbuf);
        return (-1);
    }

    /* 从连接池获取会话 */
    rc = OCISessionGet(envhp, errhp, &svchp, authp,
        (OraText *)pool_name, pool_name_len,
        NULL, 0, NULL, NULL, NULL,
        OCI_SESSGET_CPOOL
    );

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCISessionGet() - [%d] %s\n", ec, errbuf);
        return (-1);
    }

    /* 分配OCI语句句柄 */
    rc = OCIHandleAlloc(
        (void *)envhp,
        (void **)&stmthp,
        OCI_HTYPE_STMT,
        0,
        (void **)NULL
    );

    if (rc != OCI_SUCCESS) {
        fprintf(stderr, "OCIHandleAlloc() - allocate statement handle error !\n");
        return (-1);
    }

    /* 产生SQL语句文本 */
    strcpy(sqltxt, "select 10 from dual");
    slen = strlen(sqltxt);

    /* 准备语句 */
    rc = OCIStmtPrepare(stmthp, errhp, (const OraText *)sqltxt, slen,
          OCI_NTV_SYNTAX, OCI_DEFAULT);

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCIStmtPrepare() - [%d] %s\n", ec, errbuf);
        return (-1);
    }

    /* 定义输出变量 */
    rc = OCIDefineByPos(stmthp,
        &defp,
        errhp,
        (ub4)1,
        (void *)&u4,
        (sb4)4,
        (ub2)SQLT_INT,
        (void *)NULL,
        (ub2 *)NULL,
        (ub2 *)NULL,
        (ub4)OCI_DEFAULT
    );

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCIDefineByPos() - [%d] %s\n", ec, errbuf);
        return (-1);
    }

    /* 执行查询语句 */
    rc = OCIStmtExecute(svchp, stmthp, errhp, 0, 0, NULL, NULL, OCI_DEFAULT);

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCIStmtExecute() - [%d] %s\n", ec, errbuf);
        return (-1);
    }

    /* 取回结果集 */
    rc = OCIStmtFetch2(stmthp, errhp, 1, OCI_FETCH_NEXT, 0, OCI_DEFAULT);

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCIStmtFetch2() - [%d] %s\n", ec, errbuf);
        return (-1);
    }

    /* 显示从数据库查询到的数值 */
    fprintf(stdout, "number from dual is: %d\n", u4);

    /* 释放语句句柄 */
    rc = OCIHandleFree(
        stmthp,
        OCI_HTYPE_STMT
    );

    if (rc != OCI_SUCCESS) {
        fprintf(stderr, "OCIHandleFree() - free statement handle error !\n");
        return (-1);
    }

    /* 释放连接池会话 */
    rc = OCISessionRelease(svchp, errhp, NULL, 0, OCI_DEFAULT);

    if (rc != OCI_SUCCESS) {
        OCIErrorGet(errhp, 1, NULL, &ec, errbuf, 512, OCI_HTYPE_ERROR);
        fprintf(stderr, "OCISessionRelease() - [%d] %s\n", ec, errbuf);
        return (-1);
    }

    /* 释放认证信息句柄 */
    rc = OCIHandleFree(
        authp,
        OCI_HTYPE_AUTHINFO
    );

    if (rc != OCI_SUCCESS) {
        fprintf(stderr, "OCIHandleFree() - free authentication handle error !\n");
        return (-1);
     }

    return (0);
}

/* 主函数 */
int main(int argc, char *argv[])
{
    /* 解析命令行参数 */
    if (parse_inputs(argc, argv) < 0)
        return (-1);

    /* 检查Oracle运行环境变量是否设置 */
    if (check_ora_env() < 0)
        return (-1);

    /* 创建连接池 */
    if (create_connection_pool() < 0)
        goto error_exit;

    /* 从数据库中查询数值 */
    if (query_from_dual() < 0)
        fprintf(stderr, "query operation error !\n");

    /* 销毁连接池 */
    destroy_connection_pool();

    return (0);

error_exit:
    destroy_connection_pool();
    return (-1);
}

例子中使用了OCISessionGet()函数来获取连接池会话，要比使用OCILogon2()函数复杂一些，仔细看一下，Oracle提供的示例代码中没有演示OCISessionGet()函数的用法。

tomcoding
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++ Oracle OCCI 编程
墨鱼菜鸡
07-11 1023
来源：http://blog.csdn.net/gumingyaotangwei/article/details/7337893 OCCI数据库Oracle编程步骤1．配置环境(1)Occi访问数据库需要occi.h头文件，此文件在oracle安装目录下，必须有oracle库的支持。安装oracle服务端或客户端；(2)配置NLS_LANG环境变...
达梦数据库-oci编程例子
02-26
在实际项目中，oci编程可以应用于各种场景，如数据库批量导入导出、复杂查询优化、数据库连接池管理等。熟悉oci接口的开发者在面对达梦数据库这样的非Oracle环境时，也能游刃有余，实现高效的数据操作。
OCI编程高级篇（二十二） OCI多线程编程和示例代码
最新发布
tomcoding的博客
09-06 121
OCI多线程编程的实际例子，介绍了多线程怎样使用连接池的，哪些函数在主线程调用，哪些函数在子线程中调用。
OCI编程基础篇（三） 连接到数据库
tomcoding的博客
08-06 711
分配必须的句柄，连接到数据库，建立用户会话
JDBC基础整理（快速入门、自定义连接池）
weixin_34319374的博客
11-08 67
JDBC是什么 Java数据库连接（Java DataBase Connectivity） 是Java提供的一套用于连接、操作数据库的一套接口规范，即使用Java语言来操作数据库 为什么需要有JDBC 就像车子跑起来需要发动机的驱动，显卡等电脑硬件想运行起来需要显卡驱动，使用Java语言操作相应的数据库也需要相应的驱动 但存在一个问题，数...
C++ Oracle occi 编程
章志强的专栏
07-24 907
OCCI数据库ORACLE编程步骤 1． 配置环境 （1） Occi访问数据库需要occi.h头文件，此文件在oracle安装目录下，必须有oracle库的支持。安装oracle服务端或客户端； （2） 配置NLS_LANG环境变量，必须与数据库的字符编码一致，否则可能出现中文乱码； （3） 配置环境变量，使客户端支持中文显示； （4） 安装C++编程工具和g++编译工具。 2． 编写C++程序 ...
系统架构设计师【第6章】: 数据库设计基础知识 (核心总结)
数据知道的博客
05-30 6942
介绍数据库技术 的发展历程以及数据模型、主流的关系数据库、数据库设计的步骤与方法、新型数据库 NoSQL。
数据库编程总结
热门推荐
深之JohnChen的专栏
04-11 5万+
数据库编程总结当前各种主流数据库有很多，包括Oracle, MS SQL Server, Sybase, Informix, MySQL, DB2, Interbase / Firebird, PostgreSQL, SQLite, SAP/DB, TimesTen, MS ACCESS等等。数据库编程是对数据库的创建、读写等一列的操作。数据库编程分为数据库客户端编程与数据库服务器端编程。数据
Oracle SQL高级编程
weixin_30564901的博客
05-23 177
查看书籍详细信息： Oracle SQL高级编程 编辑推荐 　　资深Oracle专家力作，OakTable团队推荐 　　全面、独到、翔实，题材丰富 　　Oracle开发人员和DBA必备 内容简介 　　Oracle 数据库中的SQL是当今市场上功能最强大的SQL实现之一，而本书全面展示了这一工具的威力。如何才能...
VC数据库编程总结(二)
yuvmen的专栏
09-12 3627
非常详尽地介绍了VC中数据库编程的各种方法，大侠们长期经验的总结，不可多得的文章。
OCI数据库编程
06-05
oci_inter_project.zip ...同时，这也为深入研究PL/SQL、Oracle数据库的高级特性，以及数据库连接池等进阶主题打下坚实基础。对于想要提升数据库开发技能的程序员来说，这是一个不容错过的学习资源。
oci.example.rar_C++ OCI_oci_oci example
09-19
1. **连接管理**：示例可能会展示如何使用`OCILogon2`函数创建数据库会话，`OCISessionPool`用于创建会话池，以及`OCILogoff`来断开会话。 2. **环境和错误处理**：C++代码会设置环境句柄（`OCIEnvCreate`）和错误...
Oracle SQL高级编程(资深Oracle专家力作，OakTable团队推荐)--随书源代码
02-04
该资料是《Oracle SQL高级编程》的源代码 对应的书籍资料见: Oracle SQL高级编程(资深Oracle专家力作，OakTable团队推荐) 基本信息 原书名： Pro Oracle SQL 原出版社： Apress 作者： (美)Karen Morton Kerry ...
数据同步是如何实现的？为什么需要数据同步？
oOBubbleX的博客
09-05 652
实时数据同步，确保数据的一致性和实时更新性，将有利于企业各部门之间高效协作，从而支持企业的业务运作和决策。本文将介绍数据同步概念、数据同步的步骤、数据同步的方式，从而加深对数据同步的认识。
Redis基础命令和事务，redis持久化和主从复制
baomingshu的博客
08-31 1868
nosql数据库介绍：解释为 non-relational(非关系型数据库)。在NoSQL 数据库中数据之间是无联系的数据的结构是松散的，可变的。优势：大数据量，高性能，灵活的数据模型，高可用，低成本劣势：（1）无关系，数据之间是无联系的。
编译原理简介
m0_52796585的博客
09-01 1091
编译原理是计算机科学中的一个核心领域，它涉及到将高级编程语言编写的源代码转换成机器语言的过程。这个过程对于计算机程序的运行至关重要，因为计算机硬件只能理解机器语言指令。编译原理不仅关注编译器的设计和实现，还涉及语言的语义、语法分析、代码优化等多个方面。
您应该使用哪个矢量数据库？ 选择最适合您需求的数据库
weixin_41446370的博客
09-01 1676
在现实世界中，并非所有数据都能整齐地排列成行和列。在处理复杂的非结构化数据（如图像、视频和自然语言）时尤其如此。矢量数据库是一种以高维矢量形式存储数据的数据库，本质上是代表对象特征或特性的数字列表。每个矢量对应一个独特的实体，如一段文本、图像或视频。但为什么要使用矢量呢？奥妙就在于它能够捕捉语义和相似性。通过将数据表示为向量，我们可以对它们进行数学比较，并确定它们的相似或不相似程度。这使我们能够执行复杂的查询，如 "为我查找与此相似的图片 "或 “检索与此文本语义相关的文档”。
如何防止常见的Web应用安全漏洞！
MJH827的博客
09-04 600
Web应用的广泛使用伴随着各种安全威胁。近年来，许多企业因忽视Web应用的安全性而遭受重大损失。本文将介绍几种常见的Web应用安全漏洞，并提供具体的防护方案和实战演练。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值