oci批量提取oracle数据写入mongodb或写成bson文件

项目需要，将oracle中上亿的数据表数据提取到mongdb，通过api单条插入，效率极低。通过第三方工具data-integration导入，效率还不够高。最终只能根据需求编写程序。

最初思路是解析oracle导出的dump二进制文件，在转换为bson二进制导入mongodb，但是根据测试，效率依旧较低。发现oracle与mongodb都采用批处理，效率算数有进步，最终决定采用编写程序实现。以下是在centos测试机器1万批量测得，鉴于代码未继续优化以及主机性能不强，后续效率还待测试：

在oracle导入mongodb时，通过oci批量提取数据，调用mongc driver批量写入mongddb，大幅提升效率，120万批量处理速度约21845条/s。代码还可继续优化，如使用oracle分页技术分多进程，理论提高页数倍，如有更好方式，也请分享，谢谢。以下为100万批量处理时速度记录：

oci程序中批量提取函数OCIDefineArrayOfStruct只能绑定静态数据，通过malloc开辟连续空间实现静态数组即可。以下为测试代码，后续请自行改进(需具备oci、mongodb、mongodb c driver、bson知识)：

ToBson.h:

/**
* @file  ToBson.h
* @brief 导出ORACLE数据表或JSON文件为SBON文件、查看BSON文件工具
* @author   wangcc3
* @date     2018-1-5
* @version  001
* @copyright Copyright (c) 2018,AsiaInfo(FzOcs)
*/
#ifndef _TO_BSON_H_
#define _TO_BSON_H_

#include <string>
#include <oci.h>
#include <bson.h>
#include <bcon.h>
#include <mongoc.h>

namespace BM35 {

using namespace std;

// 地址对齐
#define ALIGNMENT 8
#define ADDRPADDING(p, a) (uintptr_t)(((uintptr_t)a - ((uintptr_t)p % (uintptr_t)a)) % (uintptr_t)a)
#define ADDRALIGN(p, a) (char *)(((uintptr_t)p + ((uintptr_t)a - 1))&~((uintptr_t)a -1))

// 默认最大行数
#define _MAX_ROW_NUMS_ 1000000

/*
typedef unsigned char  ub1;
typedef   signed char  sb1;
typedef unsigned short    ub2;
typedef   signed short    sb2;
typedef unsigned int  ub4;
typedef   signed int  sb4;
typedef         ub4      duword;
typedef         sb4      dsword;
typedef         dsword   dword;
*/

// oracle句柄结构体
typedef struct _oci_env_
{
    OCIEnv      *envhp;
    OCIError    *errhp;
    OCISvcCtx   *svchp;
    OCIServer   *srvhp;
    OCISession	*usrhp;
    OCIStmt	    *smthp;
    OCIParam    *paramhp;
} OCI_ENV;

// 字段信息
class OracleField {
public:
    char *colName;
    char *colPoint;
    int	colScale;
    int colOffset;
    ub2 colType;
    ub2 colDefineType;
    ub2 coLen;
    ub4 colNameLen;
    OCIDefine *ociDefine;
};

// 配置结构体
class OCI_CONF
{
public:
    int flag;
    long rownum;
    long long begin;
    long long end;
    string table;
    string sql;
    string bfile; //可空
    string jfile;
    string tns;
    string user;
    string passwd;
    string mongouri;
    string mongodb;
    string mongocollection;

    void init() {
        flag = 0;
        rownum = 0;
        begin = -1;
        end = -1;
        table = "";
        sql = "";
        bfile = ""; //可空
        jfile = "";
        passwd = "";
        user = "";
        tns = "";
        mongouri = "";
        mongodb = "";
        mongocollection = "";
    }
};

class ToBson
{

public:

    ToBson();
    ~ToBson();

    // 运行入口
    bool run(string & sJsonFile);

    // 运行入口
    bool run(OCI_CONF & conf);

    // 获得错误信息
    string getErrInfo();


private:

    // 运行
    bool run();

    // 输出容器配置信息
    void printConf(vector<OCI_CONF>::iterator vIter);

    // 关闭BSON文件
    void closeFile();

    /* flag: 1ORACLETOBSON  2JSONTOBSON  3BSONTOJSON 4READBSON 5BSONNUMS 6ORACLETOMONGODB
     * 解析配置文件config.json:
     {"note":"遍历完所有flag=1 or 6的配置时，tns、user、passwd三个字段必须存在，字段实际生效按第一次出现配置"}
     {"note":"遍历完所有flag=6的配置时，uri、mdb二个字段必须存在，字段实际生效按第一次出现配置"}
     {"note":"flag: 1ORACLETOBSON  2JSONTOBSON  3BSONTOJSON 4READBSON 5BSONNUMS 6ORACLETOMONGODB"}
     {"flag":1,"tns":"SiC","user":"comm","passwd":"comm","table":"TEST9","bfile":"./TEST9.bson","sql":"","note":"bfile,[sql/table] can empty"}
     {"flag":1,"table":"TEST10","bfile":"./TEST10.bson"}
     {"flag":2,"bfile":"./test.bson","jfile":"./test.json","begin":0,"end":4,"note":"write 0-4 line json to bson file,default all"}
     {"flag":3,"bfile":"./test.bson","jfile":"./test.json","begin":0,"end":4,"note":"write 0-4 line bson to json file,default all"}
     {"flag":4,"bfile":"./TEST9.bson","begin":0,"end":4,"note":"read 0-4 line bson file info,default first 10 line"}
     {"flag":5,"bfile":"./TEST9.bson","note":"get bson file line nums"}
     {"flag":6,"table":"TEST9","uri":"mongodb://192.168.1.123:20000/","mdb":"mongodb","collection":"TEST9","note":"read oracle to mongodb"}
    */
    bool ParseConfig(string sJsonFile);

    // 获得SQL表名
    bool getTableName(char * sql, string &strOut, bool onlyTable = true);

    // 端口ORACLE连接
    bool closeOracle();

    // 端口MONGODB连接
    bool closeMongodb();

    // 将JSON文件写成BSON文件
    bool writeBson(string sJsonFile, string sBsonFile, long lBegin = -1, long lEnd = -1);

    // 将BSON文件写成JSON文件
    bool writeJson(string sBsonFile, string sJsonFile, long lBegin = -1, long lEnd = -1);

    // 初始化参数
    bool initParameter(const string tableName = "",
                       const string fileName = "",
                       const long maxRowNum = _MAX_ROW_NUMS_);

    // 初始化MONGODB参数
    bool initMongodb(const string database = "",
                     const string table = "");

    // 设置SQL语句
    bool setSql(string sSql);

    // 连接ORACLE
    bool connectOracle(text *dnName,text *userName, text *passWord);

    // 连接MONGODB
    bool connectMongodb(const string &uri);

    // 打开MONGODB数据库
    bool useDB(const string &databaseName);

    // 使用MONGODB数据表
    bool useTable(const string &tableName);

    // 插入MONGODB
    bool insert(string & sJsonDoc);

    // 将表数据写成BSON文件
    bool writeTableInfo();

    // 写入BSON文件
    bool writeBson(bson_t * bsonDoc, FILE *fp);

    // 检测ORACLE错误
    bool checkErr(OCIError *pErr, sword lSattus);

    // 打开BSON文件
    bool openFile(const char * sFileName);

    // 读取BSON文件信息
    bool readBson(string sBsonFile, long lBegin = -1, long lEnd = -1);

    // 获得ORACLE定义类型
    ub2 getDefineType(ub2 iType);

    // 获得缓存列偏移量
    int getOffset(int col);

    // 获得BSON文件记录数
    long getBsonNum(string sBsonFile);

    // 获得当前系统时间
    string getTime();

    // 去除换行
    string trimNewline(char * str);


private:

    bool bIsSetSql;
    bool isOracle;
    bool isMongodb;
    bool isWriteMongo;
    bool isInitDb;
    char sTnsName[32];
    char sUserName[32];
    char sPassWord[32];
    char sTableName[32];
    char sErr[512] = {0};
    char sqlText[512];
    char rowNum[32];
    string sSqlTable;
    string sSqlRow;
    string sBsonFile;
    string errMsg;
    string nowTable;
    string mDatabaseName;
    string mTableName;
    string mUri;
    char *pBuf;
    char *pBufPoint;
    text *colName;
    FILE *fp;
    bson_t * docBson;
    mongoc_client_t      *mClient;
    mongoc_database_t    *mDatabase;
    mongoc_collection_t  *mCollection;
    mongoc_bulk_operation_t *bulk;
    OCIDefine *dfnhp;
    OracleField *pOracleField;
    int iRowLen;
    ub2 coLen;
    ub4 colNum;
    ub4 colnameLen;
    ub4 rrows;
    ub4 psz;
    sb4 para_status;
    sb4 status;
    long lMaxRowNum;
    long lBufSize;
    long long lNowRow;
    long bsonNums;
    bson_t bsonDoc;
    bson_error_t  bson_error;
    OCI_ENV stOciEnv;
    vector<OCI_CONF> vConf;
    vector<OCI_CONF>::iterator vIter;

};

}

#endif //_TO_BSON_H_

ToBson.cpp:

/**
* @file  ToBson.cpp
* @brief 导出ORACLE数据表或JSON文件为SBON文件、查看BSON文件工具
* @author   wangcc3
* @date     2018-1-5
* @version  001
* @copyright Copyright (c) 2018,AsiaInfo(FzOcs)
*/

#include <time.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "ToBson.h"

namespace BM35 {

ToBson::ToBson() {

    fp = NULL;
    docBson = NULL;
    errMsg = "NO ERROR";
    sSqlRow = "";
    bIsSetSql = false;
    isInitDb = false;
    mDatabaseName = "";
    mTableName = "";
    mUri = "";
    mCollection = NULL;
    mDatabase = NULL;
    mClient = NULL;
    bulk = NULL;
    pOracleField = NULL;
    pBuf = NULL;
    bson_init(&bsonDoc);
    memset(sTableName, 0, sizeof(sTableName));
    memset(sqlText, 0, sizeof(sqlText));
    memset(sTnsName, 0, sizeof(sTnsName));
    memset(sUserName, 0, sizeof(sUserName));
    memset(sPassWord, 0, sizeof(sPassWord));
}

ToBson::~ToBson() {

    if(pOracleField) {
        for(int i = 0; i <colNum; i++) {
            if(pOracleField[i].colName) {
                delete [] pOracleField[i].colName;
                pOracleField[i].colName = NULL;
            }
        }
        delete[] pOracleField;
        pOracleField = NULL;
    }

    if(pBuf) {
        delete[] pBuf;
        pBuf = NULL;
    }

    closeFile();
    bson_destroy(&bsonDoc);
}

bool ToBson::initMongodb(const string database, const string table) {

    if(database.empty() && mDatabaseName.empty()) {
        errMsg = "Mongodb database is empty";
        return false;
    }

    if(!database.empty()) {
        if(!isInitDb) {
            useDB(database);
        } else if(database.compare(mDatabaseName)) {
            if(!useDB(database))
                return false;
        }
    } else
        if(!useDB(mDatabaseName))
            return false;

    if(!table.empty()) {
        useTable(table);
    } else if(!nowTable.empty()) {
        useTable(nowTable);
    } else {
        errMsg = "Mongodb table is empty";
        return false;
    }

    return true;
}

bool ToBson::initParameter(const string tableName,
                           const string fileName,
                           const long maxRowNum) {

    nowTable = "";
    if(!tableName.empty()) {
        strcpy(sTableName, tableName.c_str());
        nowTable = sTableName;
    } else if(bIsSetSql) {
        if(!getTableName(sqlText, nowTable)) {
            errMsg = "Parsing sql failure when getting the table name";
            return false;
        }
    } else {
        errMsg = "Parameter tableName and sql is empty";
        return false;
    }

    if(!fileName.empty())
        sBsonFile = fileName;
    else
        sBsonFile = "./" + nowTable + ".bson";

    lMaxRowNum = maxRowNum;
    return true;
}

void ToBson::printConf(vector<OCI_CONF>::iterator vIter) {

    cout<<endl;
    cout<<"Config Info:"<<endl;
    cout<<"flag="<<vIter->flag<<endl;
    cout<<"table="<<vIter->table<<endl;
    cout<<"jfile="<<vIter->jfile<<endl;
    cout<<"bfile="<<vIter->bfile<<endl;
    cout<<"rownum="<<vIter->rownum<<endl;
    cout<<"sql="<<vIter->sql<<endl;
    cout<<"begin="<<vIter->begin<<endl;
    cout<<"end="<<vIter->end<<endl;
    cout<<endl;
}

string ToBson::trimNewline(char * str) {
    string _str = str;
    if(!_str.empty() )
    {
        _str.erase(_str.find_last_not_of('\r') + 1);
        _str.erase(_str.find_last_not_of('\n') + 1);
    }
    return _str;
}

bool ToBson::run(OCI_CONF & conf) {

    vConf.clear();
    if(conf.flag == 1 || conf.flag == 6) {
        if(conf.tns.empty() ||
                conf.user.empty() ||
                conf.passwd.empty()) {
            errMsg = "Parameter of tns or user or passed is empty";
            return false;
        }
        strcpy(sTnsName, conf.tns.c_str());
        strcpy(sUserName, conf.user.c_str());
        strcpy(sPassWord, conf.passwd.c_str());
        isOracle = true;

        if(conf.flag == 6) {
            if(conf.mongodb.empty() ||
                    conf.mongouri.empty()) {
                errMsg = "Parameter of muri or mdb is empty";
                return false;
            }
            mDatabaseName = conf.mongodb;
            mTableName = conf.mongocollection;
            mUri = conf.mongouri;
            isMongodb = true;
        } else
            isMongodb = false;
    } else
        isOracle = false;

    vConf.push_back(conf);
    return run();
}

bool ToBson::run(string & sJsonFile) {

    if(!ParseConfig(sJsonFile))
        return false;
    return run();
}

bool ToBson::run() {

    long count = 0;

    if(isOracle) {
        // check environment
        //export NLS_LANG=AMERICAN_AMERICA.ZHS16GBK
        //Chinese: export NLS_LANG=AMERICAN_AMERICA.UTF8
        if(getenv("NLS_LANG") == NULL)
        {
            errMsg = "Set env NLS_LANG first";
            return false;
        }

        if(!connectOracle((text *)sTnsName, (text *)sUserName, (text *)sPassWord))
            return false;

        if(isMongodb)
            if(!connectMongodb(mUri))
                return false;
    }

    cout<<endl;
    for (vIter=vConf.begin(); vIter!=vConf.end(); vIter++) {
        if(vIter->flag == 1 ||
                vIter->flag == 6) {
            if(!isOracle) {
                errMsg = "Can't connect oracle";
                cout<<getErrInfo()<<endl;
                printConf(vIter);
                continue;
            }
            if((vIter->flag == 6) && !isMongodb) {
                errMsg = "Can't connect mongodb";
                cout<<getErrInfo()<<endl;
                printConf(vIter);
                continue;
            }
            if(!vIter->sql.empty())
                setSql(vIter->sql);
            if(!vIter->rownum)
                vIter->rownum = _MAX_ROW_NUMS_;
            if(!initParameter(vIter->table,vIter->bfile,vIter->rownum)) {
                cout<<getErrInfo()<<endl;
                printConf(vIter);
                continue;
            }
            if(vIter->flag == 6) {
                if(!initMongodb(vIter->mongodb, vIter->mongocollection)) {
                    cout<<getErrInfo()<<endl;
                    printConf(vIter);
                    continue;
                }
                isWriteMongo = true;
            } else
                isWriteMongo = false;

            cout<<"Begin time:"<<getTime()<<endl;
            if(!writeTableInfo()) {
                cout<<getErrInfo()<<endl;
                printConf(vIter);
                continue;
            }
            cout<<"End time:"<<getTime()<<endl<<endl;
        } else if(vIter->flag == 2) {
            if(!writeBson(vIter->jfile, vIter->bfile, vIter->begin, vIter->end)) {
                cout<<getErrInfo()<<endl;
                printConf(vIter);
                continue;
            }
        } else if(vIter->flag == 3) {
            if(!writeJson(vIter->bfile, vIter->jfile, vIter->begin, vIter->end)) {
                cout<<getErrInfo()<<endl;
                printConf(vIter);
                continue;
            }
        } else if(vIter->flag == 4) {
            if(!readBson(vIter->bfile,vIter->begin,vIter->end)) {
                cout<<getErrInfo()<<endl;
                printConf(vIter);
                continue;
            }
        } else if(vIter->flag == 5) {
            cout<<"file "<<vIter->bfile<<" record nums="<<getBsonNum(vIter->bfile)<<endl<<endl;
        }
        count++;
    }

    cout<<endl<<"Total finish "<<count<<" config tasks"<<endl<<endl;

    if(isOracle) {
        if(!closeOracle())
            return false;

        if(isMongodb)
            if(!closeMongodb())
                return false;
    }

    return true;
}

bool ToBson::closeMongodb() {

    if(mCollection)
        mongoc_collection_destroy (mCollection);

    if(mDatabase)
        mongoc_database_destroy (mDatabase);

    if(mClient)
        mongoc_client_destroy (mClient);

    mongoc_cleanup ();
    return true;
}

string ToBson::getErrInfo() {
    return errMsg;
}

bool ToBson::getTableName(char * sql, string &strOut, bool onlyTable) {

    if(!sql || !strlen(sql)) {
        errMsg = "sql is empty";
        return false;
    }
    string strSql= sql;
    string find_begin = "from";
    size_t begin_postion;
    begin_postion = strSql.find(find_begin);
    if(onlyTable) {
        string find_end = "where";
        size_t end_postion = strSql.find(find_end);
        if (end_postion != string::npos)
            strOut = strSql.substr(begin_postion+5, end_postion-begin_postion-6);
        else
            strOut = strSql.substr(begin_postion+5);
    } else {
        if (begin_postion != string::npos)
            strOut = strSql.substr(begin_postion+5);
        else
            return false;
    }
    return true;
}

string ToBson::getTime() {

    char year[5] = {0};
    char month[3] = {0};
    char day[3] = {0};
    char hour[3] = {0};
    char min[3] = {0};
    char second[3] = {0};
    char nowTime[20] = {0};
    //string cNowTime = "";
    time_t timep;
    struct tm *p;

    time(&timep);
    p = localtime(&timep);

    sprintf(year,"%d",1900 + p->tm_year);

    if(p->tm_mon < 10)
        sprintf(month, "0%d", 1 + p->tm_mon);
    else
        sprintf(month, "%d", 1 + p->tm_mon);

    if(p->tm_mday < 10)
        sprintf(day, "0%d", p->tm_mday);
    else
        sprintf(day, "%d", p->tm_mday);

    if(p->tm_hour < 10)
        sprintf(hour,"0%d",p->tm_hour);
    else
        sprintf(hour,"%d",p->tm_hour);

    if(p->tm_min < 10)
        sprintf(min, "0%d", p->tm_min);
    else
        sprintf(min, "%d", p->tm_min);

    if(p->tm_sec < 10)
        sprintf(second,"0%d",p->tm_sec);
    else
        sprintf(second,"%d",p->tm_sec);

    sprintf(nowTime, "%s/%s/%s %s:%s:%s",year, month, day, hour, min, second);

    //cNowTime = cNowTime + year + month + day + hour + min + second;

    return string(nowTime);
}

bool ToBson::connectMongodb(const string &uri) {

    if(uri.empty()) {
        errMsg = "Mongodb database connect uri is empty";
        return false;
    }
    mongoc_init();
    mClient = mongoc_client_new(uri.c_str());
    if(!mClient) {
        errMsg = "Create mongodb client failed!\n";
        return false;
    }

    return true;
}

bool ToBson::useDB(const string &databaseName) {

    if(databaseName.empty()) {
        errMsg = "databaseName is empty\n";
        return false;
    }

    if(mCollection) {
        mongoc_collection_destroy(mCollection);
        mCollection = NULL;
    }

    if(mDatabase) {
        mongoc_database_destroy(mDatabase);
        mDatabase = NULL;
    }

    mDatabase = mongoc_client_get_database(mClient, databaseName.c_str());
    if(!mDatabase) {
        errMsg = "Mongodb get database failed";
        return false;
    }

    isInitDb = true;
    return true;
}

bool ToBson::insert(string & sJsonDoc) {

    docBson = bson_new_from_json ((const uint8_t*)sJsonDoc.c_str(), -1, &bson_error);

    if (!docBson) {
        errMsg = bson_error.message;
        return false;
    }

    if(!mongoc_collection_insert(mCollection,
                                 MONGOC_INSERT_NONE,
                                 docBson, NULL, &bson_error)) {
        errMsg = bson_error.message;
        return false;
    }

    bson_destroy (docBson);

    return true;
}

bool ToBson::useTable(const string &tableName) {

    if(tableName.empty()) {
        errMsg = "Mogndb tableName is empty\n";
        return false;
    }
    if(mCollection) {
        mongoc_collection_destroy(mCollection);
        mCollection = NULL;
    }

    if(mDatabaseName.empty()) {
        errMsg = "Mongodb database is null, use useDB to init database instacne";
        return false;
    }

    mCollection = mongoc_client_get_collection(mClient,
                                               mDatabaseName.c_str(),
                                               tableName.c_str());
    if(!mCollection) {
        errMsg = "Mongodb get collection failed";
        return false;
    }

    return true;
}

bool ToBson::connectOracle(text *dnName,text *userName, text *passWord) {

    OCIEnvCreate(&stOciEnv.envhp, OCI_DEFAULT, (dvoid *) 0, 0, 0, 0, (size_t) 0, (dvoid **) 0);
    OCIHandleAlloc((dvoid *) stOciEnv.envhp, (dvoid **)&stOciEnv.errhp, OCI_HTYPE_ERROR, 0, (dvoid **) 0);
    OCIHandleAlloc((dvoid *) stOciEnv.envhp, (dvoid **)&stOciEnv.srvhp, OCI_HTYPE_SERVER, 0, (dvoid **) 0);
    if(OCIServerAttach(stOciEnv.srvhp, stOciEnv.errhp, (text *) dnName, strlen((char *) dnName), OCI_DEFAULT) != OCI_SUCCESS) {
        errMsg = "Connection database failure";
        return false;
    }
    OCIHandleAlloc((dvoid *) stOciEnv.envhp, (dvoid **) &stOciEnv.svchp, OCI_HTYPE_SVCCTX, (size_t) 0, (dvoid **) 0);
    OCIAttrSet((dvoid *) stOciEnv.svchp, OCI_HTYPE_SVCCTX, (dvoid *) stOciEnv.srvhp, (ub4) 0, OCI_ATTR_SERVER, (OCIError *) stOciEnv.errhp);
    OCIHandleAlloc((dvoid *) stOciEnv.envhp, (dvoid **) &stOciEnv.usrhp, OCI_HTYPE_SESSION, (size_t) 0, (dvoid **) 0);
    OCIAttrSet((dvoid *) stOciEnv.usrhp, OCI_HTYPE_SESSION, (dvoid *) userName, (ub4) strlen((char *) userName), (ub4) OCI_ATTR_USERNAME, stOciEnv.errhp);
    OCIAttrSet((dvoid *) stOciEnv.usrhp, OCI_HTYPE_SESSION, (dvoid *) passWord, (ub4) strlen((char *) passWord), (ub4) OCI_ATTR_PASSWORD, stOciEnv.errhp);
    OCIAttrSet((dvoid *) stOciEnv.svchp, OCI_HTYPE_SVCCTX, (dvoid *) stOciEnv.usrhp, (ub4) 0, OCI_ATTR_SESSION, (OCIError *) stOciEnv.errhp);
    if(OCISessionBegin(stOciEnv.svchp, stOciEnv.errhp, stOciEnv.usrhp, OCI_CRED_RDBMS, OCI_DEFAULT) != OCI_SUCCESS) {
        errMsg = "Setting up user session failure";
        return false;
    }

    if(!checkErr(stOciEnv.errhp, OCIHandleAlloc((dvoid *) stOciEnv.envhp, (dvoid **) &stOciEnv.smthp, OCI_HTYPE_STMT, (size_t) 0, (dvoid **) 0 )))
        return false;
    return true;
}

bool ToBson::openFile(const char * sFileName) {

    if(!sFileName) {
        errMsg = "File is null";
        return false;
    }

    if((fp=fopen(sFileName,"w+"))==NULL) {
        errMsg = "Fail to open file";
        return false;
    }
    return true;
}

void ToBson::closeFile() {

    if(fp) {
        fclose(fp);
        fp = NULL;
    }
}

bool ToBson::ParseConfig(string sJsonFile) {

    if(sJsonFile.empty()) {
        errMsg = "Config file path is empty";
        return false;
    }
    vConf.clear();
    OCI_CONF tmpConf;
    tmpConf.init();
    string key;
    uint32_t len=0;
    bson_json_reader_t *reader;
    bson_error_t error;
    bson_t doc = BSON_INITIALIZER;
    int b;
    bson_iter_t iter;
    char errInfo[256] = { 0 };

    if (!(reader = bson_json_reader_new_from_file (sJsonFile.c_str(), &error))) {
        sprintf(errInfo, "Fail to open the json config file:%s", error.message);
        errMsg = errInfo;
        return false;
    }

    while ((b = bson_json_reader_read (reader, &doc, &error))) {
        if (b < 0) {
            //continue;
            sprintf(errInfo, "Parsing json file failure:%s", error.message);
            errMsg = errInfo;
            return false;
        }

        if (bson_iter_init(&iter, &doc)) {
            while(bson_iter_next(&iter)) {
                key = bson_iter_key(&iter);
                if(BSON_ITER_HOLDS_UTF8(&iter)) {
                    if(!key.compare("tns")) {
                        if(!strlen(sTnsName))
                            strcpy(sTnsName, bson_iter_utf8(&iter,&len));
                    } else if(!key.compare("user")) {
                        if(!strlen(sUserName))
                            strcpy(sUserName, bson_iter_utf8(&iter,&len));
                    } else if(!key.compare("passwd")) {
                        if(!strlen(sPassWord))
                            strcpy(sPassWord, bson_iter_utf8(&iter,&len));
                    } else if(!key.compare("table")) {
                        tmpConf.table = bson_iter_utf8(&iter,&len);
                    } else if(!key.compare("sql")) {
                        tmpConf.sql = bson_iter_utf8(&iter,&len);
                    } else if(!key.compare("bfile")) {
                        tmpConf.bfile = bson_iter_utf8(&iter,&len);
                    } else if(!key.compare("jfile")) {
                        tmpConf.jfile = bson_iter_utf8(&iter,&len);
                    } else if(!key.compare("uri")) {
                        if(mUri.empty())
                            mUri = bson_iter_utf8(&iter,&len);
                    } else if(!key.compare("mdb")) {
                        tmpConf.mongodb = bson_iter_utf8(&iter,&len);
                        if(mDatabaseName.empty())
                            mDatabaseName = tmpConf.mongodb;
                    } else if(!key.compare("collection")) {
                        tmpConf.mongocollection = bson_iter_utf8(&iter,&len);
                    } else
                        continue;
                } else if(BSON_ITER_HOLDS_INT64(&iter)) {
                    if(!key.compare("flag")) {
                        tmpConf.flag = bson_iter_int64(&iter);
                    } else if(!key.compare("rownum")) {
                        tmpConf.rownum = bson_iter_int64(&iter);
                    } else if(!key.compare("begin")) {
                        tmpConf.begin = bson_iter_int64(&iter);
                    } else if(!key.compare("end")) {
                        tmpConf.end = bson_iter_int64(&iter);
                    } else
                        continue;
                } else if(BSON_ITER_HOLDS_INT32(&iter)) {
                    if(!key.compare("flag")) {
                        tmpConf.flag = bson_iter_int32(&iter);
                    } else if(!key.compare("rownum")) {
                        tmpConf.rownum = bson_iter_int32(&iter);
                    } else if(!key.compare("begin")) {
                        tmpConf.begin = bson_iter_int32(&iter);
                    } else if(!key.compare("end")) {
                        tmpConf.end = bson_iter_int32(&iter);
                    } else
                        continue;
                } else {
                    errMsg = "Conf file data type error";
                }
            }
            if(tmpConf.flag == 1 ||
                    tmpConf.flag == 2 ||
                    tmpConf.flag == 3 ||
                    tmpConf.flag == 4 ||
                    tmpConf.flag == 5 ||
                    tmpConf.flag == 6) {
                vConf.push_back(tmpConf);
                tmpConf.init();
            }

        } else {
            errMsg = "init bson iter error!";
            return false;
            //continue;
        }
        bson_reinit (&doc);
    }

    bson_json_reader_destroy (reader);
    bson_destroy (&doc);

    if(vConf.empty()) {
        errMsg = "Conf vector are empty, initialization failed";
        return false;
    }

    if(strlen(sTnsName) &&
            strlen(sUserName) &&
            strlen(sPassWord))
        isOracle = true;
    else
        isOracle = false;

    if(mUri.empty() ||
            mDatabaseName.empty())
        isMongodb = false;
    else
        isMongodb = true;

    return true;
}

bool ToBson::writeJson(string sBsonFile, string sJsonFile, long lBegin, long lEnd) {

    if(sBsonFile.empty()) {
        errMsg = "The parameter sBsonFile is empty";
        return false;
    }

    if(sJsonFile.empty()) {
        errMsg = "The parameter sJsonFile is empty";
        return false;
    }

    FILE *jsonfp;
    char errInfo[256] = { 0 };
    bson_reader_t *reader;
    const bson_t *b;
    bson_error_t error;
    long lCount = 0;

    if(!(reader = bson_reader_new_from_file(sBsonFile.c_str(), &error))) {
        sprintf(errInfo, "Fail to open the bson file:%s", error.message);
        errMsg = errInfo;
        return false;
    }

    if((jsonfp=fopen(sJsonFile.c_str(),"w+"))==NULL) {
        errMsg = "Fail to open the bson file";
        return false;
    }

    while((b = bson_reader_read (reader, NULL))) {

        if(lEnd >= 0) {
            if(lCount >= lEnd)
                break;
        }

        if(lBegin > lCount) {
            lCount ++;
            continue;
        }

        fprintf(jsonfp, "%s\n", bson_as_json (b, NULL));
        lCount ++;
    }
    fclose(jsonfp);
    bson_reader_destroy (reader);
    return true;
}

bool ToBson::writeBson(string sJsonFile, string sBsonFile, long lBegin,long lEnd) {

    //参数 /ccw/test.json   /ccw/test.bson
    if(sJsonFile.empty() || sBsonFile.empty()) {
        errMsg = "Parameter jsonfile or bsonfile is empty";
        return false;
    }

    FILE *bsonfp;
    bson_json_reader_t *reader;
    bson_error_t error;
    bson_t doc = BSON_INITIALIZER;
    int b;
    char errInfo[256] = { 0 };
    long lCount = 0;

    if((bsonfp=fopen(sBsonFile.c_str(),"w+"))==NULL) {
        errMsg = "Fail to open the bson file";
        return false;
    }

    if (!(reader = bson_json_reader_new_from_file (sJsonFile.c_str(), &error))) {
        sprintf(errInfo, "Fail to open the json file:%s", error.message);
        errMsg = errInfo;
        return false;
    }

    while ((b = bson_json_reader_read (reader, &doc, &error))) {
        if (b < 0) {
            sprintf(errInfo, "Parsing json file failure:%s", error.message);
            errMsg = errInfo;
            return false;
        }

        if(lEnd >= 0) {
            if(lCount >= lEnd)
                break;
        }

        if(lBegin > lCount) {
            lCount ++;
            continue;
        }

        if (fwrite (bson_get_data(&doc), 1, doc.len, bsonfp) != doc.len) {
            errMsg = "Write file failure";
            return false;
        }

        lCount ++;
        bson_reinit (&doc);
    }

    bson_json_reader_destroy (reader);
    bson_destroy (&doc);
    fclose(bsonfp);
    return true;
}

bool ToBson::writeBson(bson_t * bsonDoc, FILE *fp) {

    if(!fp) {
        errMsg = "File pointers are not initialized";
        return false;
    }

    if (fwrite(bson_get_data(bsonDoc), 1, bsonDoc->len, fp) != bsonDoc->len) {
        errMsg = "Invocation of fwrite() error, write file failure";
        return false;
    }

    return true;
}

long ToBson::getBsonNum(string sBsonFile) {

    if(sBsonFile.empty()) {
        errMsg = "Parameter sBsonFile is empty";
        return -1;
    }
    char errInfo[256] = { 0 };
    bson_reader_t *reader;
    bson_error_t error;
    long lCount = 0;
    if(!(reader = bson_reader_new_from_file(sBsonFile.c_str(), &error))) {
        sprintf(errInfo, "Fail to open the bson file:%s", error.message);
        errMsg = errInfo;
        return -1;
    }

    while(bson_reader_read (reader, NULL)) {
        lCount ++;
    }

    bson_reader_destroy (reader);
    return lCount;
}

bool ToBson::readBson(string sBsonFile,long lBegin,long lEnd) {

    if(sBsonFile.empty()) {
        errMsg = "The parameter sBsonFile is empty";
        return false;
    }
    char errInfo[256] = { 0 };
    bson_reader_t *reader;
    const bson_t *b;
    bson_error_t error;
    char *str;
    long lCount = 0;
    if(!(reader = bson_reader_new_from_file(sBsonFile.c_str(), &error))) {
        sprintf(errInfo, "Fail to open the bson file:%s", error.message);
        errMsg = errInfo;
        return false;
    }

    while((b = bson_reader_read (reader, NULL))) {

        if((lBegin < 0) && (lEnd < 0)) {
            if(lCount >= 10)
                break;
        }

        if(lEnd >= 0) {
            if(lCount >= lEnd)
                break;
        }

        if(lBegin > lCount) {
            lCount ++;
            continue;
        }

        str = bson_as_json (b, NULL);
        cout<<str<<endl;
        bson_free (str);
        lCount ++;
    }

    bson_reader_destroy (reader);
    return true;
}

bool ToBson::setSql(string sSql) {

    bIsSetSql = false;
    if(sSql.empty()) {
        errMsg = "sql is empty in setSql()";
        return false;
    }
    sprintf(sqlText, "%s" , sSql.c_str());
    bIsSetSql = true;
    return true;
}

ub2 ToBson::getDefineType(ub2 iType) {

    ub2 type;
    switch(iType) {
    case SQLT_AFC:
    case SQLT_VCS:
    case SQLT_CHR:
    case SQLT_UIN:
    case SQLT_INT:
    case SQLT_FLT:
    case SQLT_NUM:
    case SQLT_RDD:
        type = SQLT_STR;
        break;
    case SQLT_DAT:
        type = SQLT_ODT;
        break;
        //    case SQLT_FLT:
        //    case SQLT_NUM:
        //        type = SQLT_VNU;
        //        break;
    default:
        type = iType;
        break;
    }
    return type;
}

int ToBson::getOffset(int col) {

    if(col <= 0 )
        return 0;

    int offset = 0;
    int i = 0;
    for(i = col -1; i >= 0; i--) {
        offset += (pOracleField[i].coLen + ALIGNMENT -1 + 1);
    }
    return offset;
}

bool ToBson::writeTableInfo() {

    if(!bIsSetSql && !strlen(sTableName)) {
        errMsg = "TableName or sql statement is not set!";
        return false;
    }

    if(!bIsSetSql) {
        sSqlRow.clear();
        sprintf(sqlText, "select * from %s" ,sTableName);
        sSqlRow = sSqlRow + "select count(*) from " + sTableName;
    } else {
        if(!getTableName(sqlText, sSqlTable, false)) {
            errMsg = "Parsing sql failure when getting the table name";
            return false;
        }
        sSqlRow = "select count(*) from " + sSqlTable;
    }

    if(!checkErr(stOciEnv.errhp, OCIStmtPrepare(stOciEnv.smthp, stOciEnv.errhp, (text *)sSqlRow.c_str(), (ub4)sSqlRow.length(), OCI_NTV_SYNTAX, OCI_DEFAULT)))
        return false;

    if(!checkErr(stOciEnv.errhp, OCIStmtExecute(stOciEnv.svchp, stOciEnv.smthp, stOciEnv.errhp, 0, 0, NULL, NULL, OCI_DEFAULT)))
        return false;

    para_status = OCIDefineByPos(stOciEnv.smthp, &dfnhp, stOciEnv.errhp, 1, (dvoid*)rowNum, sizeof(rowNum) + 1, SQLT_STR, 0, 0, 0, OCI_DEFAULT);
    if (para_status != OCI_SUCCESS) {
        checkErr(stOciEnv.errhp,para_status);
        return false;
    }

    para_status = OCIStmtFetch(stOciEnv.smthp, stOciEnv.errhp, 1, OCI_FETCH_NEXT, OCI_DEFAULT);
    if (para_status == OCI_NO_DATA) {
        errMsg = "Get rowNum error";
        return false;
    }

    cout<<"["<<nowTable<<"]Total row nums="<<rowNum<<endl;

    lNowRow = atol(rowNum);
    if(!lNowRow)
        return true;
    if(lNowRow < lMaxRowNum)
        lMaxRowNum = lNowRow;

    if(!checkErr(stOciEnv.errhp, OCIStmtPrepare(stOciEnv.smthp, stOciEnv.errhp, (text *)sqlText, (ub4)strlen((const char *) sqlText), OCI_NTV_SYNTAX, OCI_DEFAULT)))
        return false;

    if(!checkErr(stOciEnv.errhp, OCIStmtExecute(stOciEnv.svchp, stOciEnv.smthp, stOciEnv.errhp, 0, 0, NULL, NULL, OCI_DEFAULT)))
        return false;

    OCIAttrGet((dvoid*)stOciEnv.smthp, OCI_HTYPE_STMT, (dvoid*)&colNum, (ub4 *)0, OCI_ATTR_PARAM_COUNT, stOciEnv.errhp);

    pOracleField = new OracleField[colNum];
    if(!pOracleField) {
        errMsg = "Allocation field list memory failure";
        return false;
    }

    int i = 0;
    iRowLen = 0;
    for (i=0; i< colNum; i++) {
        para_status = OCIParamGet(stOciEnv.smthp, OCI_HTYPE_STMT, stOciEnv.errhp, (void **) &stOciEnv.paramhp, (ub4)i+1);
        OCIAttrGet((dvoid*)stOciEnv.paramhp, OCI_DTYPE_PARAM, (dvoid**)&colName, &pOracleField[i].colNameLen, OCI_ATTR_NAME, stOciEnv.errhp);
        pOracleField[i].colName = new char[pOracleField->colNameLen+1];
        if(!pOracleField[i].colName) {
            errMsg = "Allocation field name memory failure";
            return false;
        }
        strncpy(pOracleField[i].colName, (char*)colName, pOracleField[i].colNameLen);
        pOracleField[i].colName[pOracleField[i].colNameLen] = '\0';
        OCIAttrGet((dvoid*)stOciEnv.paramhp, OCI_DTYPE_PARAM, (dvoid *)&pOracleField[i].colScale, 0, OCI_ATTR_SCALE, stOciEnv.errhp);
        OCIAttrGet((dvoid*)stOciEnv.paramhp, OCI_DTYPE_PARAM, (dvoid*)&pOracleField[i].colType, 0, OCI_ATTR_DATA_TYPE, stOciEnv.errhp);
        OCIAttrGet((dvoid*)stOciEnv.paramhp, OCI_DTYPE_PARAM, (dvoid*)&pOracleField[i].coLen, 0, OCI_ATTR_DATA_SIZE, stOciEnv.errhp);

        if(pOracleField[i].colType == SQLT_LNG ||
                pOracleField[i].colType == SQLT_LBI ||
                pOracleField[i].colType == SQLT_LVC ||
                pOracleField[i].colType == SQLT_LVB ||
                pOracleField[i].colType == SQLT_CLOB ||
                pOracleField[i].colType == SQLT_BLOB) {
            errMsg = "Type unsupport";
            return false;
        }

        pOracleField[i].colDefineType = getDefineType(pOracleField[i].colType);
        pOracleField[i].colOffset = getOffset(i);
        iRowLen = iRowLen + pOracleField[i].coLen + (ALIGNMENT -1) + 1;
    }
    iRowLen = iRowLen + ((ALIGNMENT - (iRowLen % ALIGNMENT)) % ALIGNMENT);
    lBufSize = iRowLen * lMaxRowNum;
    pBuf = new char[lBufSize];
    if(pBuf == NULL) {
        errMsg = "Allocation buf memory failure";
        return false;
    }
    memset(pBuf, 0, lBufSize);

    for(i=0; i< colNum; i++) {
        pBufPoint = pBuf + pOracleField[i].colOffset;
        pOracleField[i].colPoint = ADDRALIGN(pBufPoint,ALIGNMENT);

        para_status = OCIDefineByPos(stOciEnv.smthp, &pOracleField[i].ociDefine, stOciEnv.errhp, i+1, (dvoid*)pOracleField[i].colPoint, (sb4)(pOracleField[i].coLen + 1), pOracleField[i].colDefineType, 0, 0, 0, OCI_DEFAULT);
        if(!checkErr(stOciEnv.errhp, para_status))
            return false;

        para_status=OCIDefineArrayOfStruct(pOracleField[i].ociDefine, stOciEnv.errhp, (ub4)iRowLen, 0, (ub4)0, 0);
        if(!checkErr(stOciEnv.errhp, para_status))
            return false;
    }

    if(!isWriteMongo) {
        if(!openFile(sBsonFile.c_str()))
            return false;
    }

    lNowRow = 0;
    char tmpStr[32] = {0};
    ub4 buf_size = 32;
    psz = sizeof(ub4);
    long j = 0;

    while(true) {

        status = OCIStmtFetch(stOciEnv.smthp, stOciEnv.errhp, lMaxRowNum, OCI_FETCH_NEXT, OCI_DEFAULT);

        if(!checkErr(stOciEnv.errhp, OCIAttrGet((dvoid *)stOciEnv.smthp, (ub4)OCI_HTYPE_STMT, (dvoid *)&rrows, (ub4 *)&psz, (ub4)OCI_ATTR_ROWS_FETCHED, stOciEnv.errhp))) {
            errMsg = "Rows fetched of OCIAttrGet() failed";
            return false;
        }

        if(!rrows)
            break;

        if(isWriteMongo) {
            bulk = mongoc_collection_create_bulk_operation(mCollection, true, NULL);
            if(!bulk) {
                errMsg = "Create bulk failed";
                return false;
            }
        }

        for(j = 0; j < rrows; j++) {
            bson_reinit(&bsonDoc);
            for(i = 0; i < colNum; i++) {
                pBufPoint = pOracleField[i].colPoint + j*iRowLen;
                //printf("value=%x\n",pBufPoint);
                switch(pOracleField[i].colType) {
                case SQLT_AFC:
                case SQLT_VCS:
                case SQLT_CHR:
                case SQLT_RDD:
                    BSON_APPEND_UTF8(&bsonDoc, pOracleField[i].colName, pBufPoint);
                    break;
                case SQLT_DAT:
                    para_status = OCIDateToText(stOciEnv.errhp,
                                                (OCIDate*)pBufPoint,
                                                (oratext*)"yyyymmddhh24miss",
                                                strlen("yyyymmddhh24miss"),
                                                (oratext*)"American",
                                                strlen("American"),
                                                &buf_size,
                                                (oratext*)tmpStr);
                    if(!checkErr(stOciEnv.errhp, para_status))
                        cout<<"Use Func OCIDateToText() failed"<<endl;
                    if(strcmp(tmpStr, "00000000000000"))
                        BSON_APPEND_UTF8(&bsonDoc, pOracleField[i].colName, tmpStr);
                    tmpStr[0] = '\0';
                    break;
                case SQLT_FLT:
                case SQLT_NUM:
                    if(strlen(pBufPoint)) {
                        if(pOracleField[i].colScale != 0)
                            BSON_APPEND_DOUBLE(&bsonDoc, pOracleField[i].colName, atof(pBufPoint));
                        else
                            BSON_APPEND_INT64(&bsonDoc, pOracleField[i].colName, atoll(pBufPoint));
                    }
                    break;
                case SQLT_UIN:
                case SQLT_INT:
                    if(strlen(pBufPoint))
                        BSON_APPEND_INT64(&bsonDoc, pOracleField[i].colName, atoll(pBufPoint));
                    break;
                case SQLT_BLOB:
                case SQLT_BIN:
                    cout<<"type nosupper"<<endl;
                    errMsg = "type nosupper";
                    break;
                default:
                    cout<<"other type nosupper"<<endl;
                    errMsg = "other type nosupper";
                    break;
                }
                pBufPoint[0] = '\0';
            }

            if(isWriteMongo) {
                mongoc_bulk_operation_insert(bulk, &bsonDoc);
            } else {
                if(!writeBson(&bsonDoc,fp))
                    return false;
            }
        }

        if(isWriteMongo) {
            if (!mongoc_bulk_operation_execute(bulk, NULL, &bson_error)) {
                errMsg = bson_error.message;
                mongoc_bulk_operation_destroy(bulk);
                return false;
            }
            mongoc_bulk_operation_destroy(bulk);
        }

        lNowRow = lNowRow + rrows;

        // When rrows is less than lMaxRowNum, also return OCI_NO_DATA
        if(status == OCI_NO_DATA)
            break;
    }

    closeFile();

    if(pOracleField) {
        for(int i = 0; i <colNum; i++) {
            if(pOracleField[i].colName) {
                delete [] pOracleField[i].colName;
                pOracleField[i].colName = NULL;
            }
        }
        delete[] pOracleField;
        pOracleField = NULL;
    }

    if(pBuf) {
        delete[] pBuf;
        pBuf = NULL;
    }

    cout <<"["<<nowTable<<"]Rows has been processed="<<lNowRow<<endl;

    return true;
}

bool ToBson::checkErr(OCIError *pErr, sword lSattus) {

    sb4 iErrCode = 0;
    switch (lSattus) {
    case OCI_SUCCESS:
        strcpy(sErr, "OCI_SUCCESS");
        break;
    case OCI_SUCCESS_WITH_INFO:
        strcpy(sErr, "OCI_SUCCESS_WITH_INFO");
        break;
    case OCI_NO_DATA:
        strcpy(sErr, "OCI_NO_DATA");
        break;
    case OCI_ERROR:
        OCIErrorGet((dvoid *) pErr, (ub4) 1, (text *) NULL, &iErrCode, (text *) sErr, (ub4) sizeof(sErr), (ub4) OCI_HTYPE_ERROR);
        break;
    case OCI_NEED_DATA:
        strcpy(sErr, "OCI_NEED_DATA");
        break;
    case OCI_INVALID_HANDLE:
        strcpy(sErr, "OCI_INVALID_HANDLE");
        break;
    case OCI_STILL_EXECUTING:
        strcpy(sErr, "OCI_STILL_EXECUTING");
        break;
    case OCI_CONTINUE:
        strcpy(sErr, "OCI_CONTINUE");
        break;
    default:
        break;
    }
    if(OCI_SUCCESS != lSattus && OCI_SUCCESS_WITH_INFO != lSattus) {
        errMsg = sErr;
        return false;
    }
    return true;
}

bool ToBson::closeOracle() {

    if(stOciEnv.smthp) {
        if(!checkErr(stOciEnv.errhp, OCIHandleFree(stOciEnv.smthp, OCI_HTYPE_STMT)))
            return false;
        stOciEnv.smthp = NULL;
    }

    if(stOciEnv.svchp && stOciEnv.errhp && stOciEnv.usrhp) {
        if(!checkErr(stOciEnv.errhp,OCISessionEnd(stOciEnv.svchp, stOciEnv.errhp, stOciEnv.usrhp, OCI_DEFAULT)))
            return false;
    }

    if (stOciEnv.usrhp) {
        if(!checkErr(stOciEnv.errhp, OCIHandleFree(stOciEnv.usrhp, OCI_HTYPE_SESSION)))
            return false;
        stOciEnv.usrhp = NULL;
    }

    if (stOciEnv.srvhp && stOciEnv.errhp) {
        if (!checkErr(stOciEnv.errhp, OCIServerDetach(stOciEnv.srvhp, stOciEnv.errhp, OCI_DEFAULT)))
            return false;
    }

    if (stOciEnv.srvhp) {
        if (!checkErr(stOciEnv.errhp, OCIHandleFree(stOciEnv.srvhp, OCI_HTYPE_SERVER)))
            return false;
        stOciEnv.srvhp = NULL;
    }

    if(stOciEnv.svchp) {
        if (!checkErr(stOciEnv.errhp, OCIHandleFree(stOciEnv.svchp, OCI_HTYPE_SVCCTX)))
            return false;
        stOciEnv.svchp = NULL;
    }

    if (stOciEnv.errhp) {
        if (!checkErr(stOciEnv.errhp, OCIHandleFree(stOciEnv.errhp, OCI_HTYPE_ERROR)))
            return false;
        stOciEnv.errhp = NULL;
    }

    if (stOciEnv.envhp) {
        if (!checkErr(stOciEnv.errhp,OCIHandleFree(stOciEnv.envhp, OCI_HTYPE_ENV)))
            return false;
        stOciEnv.envhp = NULL;
    }
    return true;
}

}

using namespace std;
using namespace BM35;

int main(int argc, char *argv[])
{
    string confFile;
    string strYN;
    string rowNum;
    string bFile;
    string jFile;
    string table;
    string end;
    string start;
    string sql;
    string tns;
    string user;
    string passwd;
    string mDb;
    string mUri;
    string mCollection;
    OCI_CONF conf;
    conf.init();
    for (int c; (c = getopt(argc, argv, "f:hHr:b:j:t:e:s:q:p:u:n:d:c:i:")) != EOF;) {
        switch (c) {
        case 'f':
            confFile = optarg;
            break;
        case 'r':
            rowNum = optarg;
            break;
        case 'i':
            mUri = optarg;
            break;
        case 'd':
            mDb = optarg;
            break;
        case 'c':
            mCollection = optarg;
            break;
        case 'p':
            passwd = optarg;
            break;
        case 'u':
            user = optarg;
            break;
        case 'n':
            tns = optarg;
            break;
        case 'b':
            bFile = optarg;
            break;
        case 'j':
            jFile = optarg;
            break;
        case 'q':
            sql = optarg;
            break;
        case 't':
            table = optarg;
            break;
        case 'e':
            end = optarg;
            break;
        case 's':
            start = optarg;
            break;
        case '?':
        case 'h':
        case 'H':
            cout<<"Usage: ToBson  \n";
            cout<<"   -f confFile [default ./ToBson.json]\n";
            cout<<"      or 1,2,3,4,5 6[1ORACLETOBSON 2JSONTOBSON 3BSONTOJSON 4READBSON 5BSONNUMS 6ORACLETOMONGODB]\n";
            cout<<"   -r rownum \n";
            cout<<"   -p passwd \n";
            cout<<"   -u user \n";
            cout<<"   -n tns \n";
            cout<<"   -b bfile \n";
            cout<<"   -j jfile \n";
            cout<<"   -q sql \n";
            cout<<"   -s start \n";
            cout<<"   -e end \n";
            cout<<"   -t table \n";
            cout<<"   -i uri \n";
            cout<<"   -d mongoDb \n";
            cout<<"   -c collection \n";
            cout<<"   -h printf help\n";
            cout<<"   example:ToBson -f ./ToBson.json \n";
            cout<<"           ToBson -f 4 -b ./test9.bson\n";
            cout<<"           ToBson -f 1 -u comm -p comm -n SiC -t test9\n";
            cout<<"           ToBson -f 6 -u comm -p comm -n SiC -t test9 -d mongodb -i mongodb://192.168.1.123:20000/\n";
            cout<<"   more detail reference file ToBson.json \n";
            exit(-1);
            break;
        default:
            break;
        }
    }

    ToBson toBson;
    if(confFile.empty()) {
        cout<<"Using ./ToBson.json file to run(y/n):"<<endl;
        cin>>strYN;
        if(!strYN.compare("Y") ||
                !strYN.compare("y"))
            confFile = "./ToBson.json";
        else
            return 0;
    } else if(!confFile.compare("1") ||
              !confFile.compare("2") ||
              !confFile.compare("3") ||
              !confFile.compare("4") ||
              !confFile.compare("5") ||
              !confFile.compare("6")) {
        conf.flag = atoi(confFile.c_str());
        if(!rowNum.empty())
            conf.rownum = atol(rowNum.c_str());
        if(!end.empty())
            conf.end = atoll(end.c_str());
        if(!start.empty())
            conf.begin = atoll(start.c_str());
        conf.bfile = bFile;
        conf.jfile = jFile;
        conf.table = table;
        conf.sql = sql;
        conf.tns = tns;
        conf.user = user;
        conf.passwd = passwd;
        conf.mongouri = mUri;
        conf.mongocollection = mCollection;
        conf.mongodb = mDb;

        if(!toBson.run(conf)){
            cout<<toBson.getErrInfo()<<endl;
            return -1;
        }
        return 0;
    }

    if(!toBson.run(confFile)){
        cout<<toBson.getErrInfo()<<endl;
        return -1;
    }
    return 0;
}

 ToBson.json：

{"note":"遍历完所有flag=1 or 6的配置时，tns、user、passwd三个字段必须存在，字段实际生效按第一次出现配置"}
{"note":"遍历完所有flag=6的配置时，uri、mdb二个字段必须存在，字段实际生效按第一次出现配置"}
{"note":"flag: 1ORACLETOBSON  2JSONTOBSON  3BSONTOJSON 4READBSON 5BSONNUMS 6ORACLETOMONGODB"}
{"flag":1,"tns":"SiC","user":"comm","passwd":"comm","table":"TEST9","bfile":"./TEST9.bson","sql":"","note":"bfile,[sql/table] can empty"}
{"flag":1,"table":"TEST10","bfile":"./TEST10.bson"}
{"flag":2,"bfile":"./test.bson","jfile":"./test.json","begin":0,"end":4,"note":"write 0-4 line json to bson file,default all"}
{"flag":3,"bfile":"./test.bson","jfile":"./test.json","begin":0,"end":4,"note":"write 0-4 line bson to json file,default all"}
{"flag":4,"bfile":"./TEST9.bson","begin":0,"end":4,"note":"read 0-4 line bson file info,default first 10 line"}
{"flag":5,"bfile":"./TEST9.bson","note":"get bson file line nums"}
{"flag":6,"table":"TEST9","uri":"mongodb://192.168.1.123:20000/","mdb":"mongodb","collection":"TEST9","note":"read oracle to mongodb"}

ToBson.json_bak：

{"flag":6,"tns":"SiC","user":"comm","passwd":"comm","table":"TEST","uri":"mongodb://192.168.1.127:27017/","mdb":"mongodb","rownum":1200000}