oracledb 3.0.0 → 3.1.2

package/odpi/src/dpiGen.c

@@ -1,303 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
-// This program is free software: you can modify it and/or redistribute it
-// under the terms of:
-//
-// (i)  the Universal Permissive License v 1.0 or at your option, any
-//      later version (http://oss.oracle.com/licenses/upl); and/or
-//
-// (ii) the Apache License v 2.0. (http://www.apache.org/licenses/LICENSE-2.0)
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-// dpiGen.c
-//   Generic routines for managing the types available through public APIs.
-//-----------------------------------------------------------------------------
-
-#include "dpiImpl.h"
-
-//-----------------------------------------------------------------------------
-// definition of handle types
-//-----------------------------------------------------------------------------
-static const dpiTypeDef dpiAllTypeDefs[DPI_HTYPE_MAX - DPI_HTYPE_NONE - 1] = {
-    {
-        "dpiConn",                      // name
-        sizeof(dpiConn),                // size of structure
-        0x49DC600C,                     // check integer
-        (dpiTypeFreeProc) dpiConn__free
-    },
-    {
-        "dpiPool",                      // name
-        sizeof(dpiPool),                // size of structure
-        0x18E1AA4B,                     // check integer
-        (dpiTypeFreeProc) dpiPool__free
-    },
-    {
-        "dpiStmt",                      // name
-        sizeof(dpiStmt),                // size of structure
-        0x31B02B2E,                     // check integer
-        (dpiTypeFreeProc) dpiStmt__free
-    },
-    {
-        "dpiVar",                       // name
-        sizeof(dpiVar),                 // size of structure
-        0x2AE8C6DC,                     // check integer
-        (dpiTypeFreeProc) dpiVar__free
-    },
-    {
-        "dpiLob",                       // name
-        sizeof(dpiLob),                 // size of structure
-        0xD8F31746,                     // check integer
-        (dpiTypeFreeProc) dpiLob__free
-    },
-    {
-        "dpiObject",                    // name
-        sizeof(dpiObject),              // size of structure
-        0x38616080,                     // check integer
-        (dpiTypeFreeProc) dpiObject__free
-    },
-    {
-        "dpiObjectType",                // name
-        sizeof(dpiObjectType),          // size of structure
-        0x86036059,                     // check integer
-        (dpiTypeFreeProc) dpiObjectType__free
-    },
-    {
-        "dpiObjectAttr",                // name
-        sizeof(dpiObjectAttr),          // size of structure
-        0xea6d5dde,                     // check integer
-        (dpiTypeFreeProc) dpiObjectAttr__free
-    },
-    {
-        "dpiSubscr",                    // name
-        sizeof(dpiSubscr),              // size of structure
-        0xa415a1c0,                     // check integer
-        (dpiTypeFreeProc) dpiSubscr__free
-    },
-    {
-        "dpiDeqOptions",                // name
-        sizeof(dpiDeqOptions),          // size of structure
-        0x70ee498d,                     // check integer
-        (dpiTypeFreeProc) dpiDeqOptions__free
-    },
-    {
-        "dpiEnqOptions",                // name
-        sizeof(dpiEnqOptions),          // size of structure
-        0x682f3946,                     // check integer
-        (dpiTypeFreeProc) dpiEnqOptions__free
-    },
-    {
-        "dpiMsgProps",                  // name
-        sizeof(dpiMsgProps),            // size of structure
-        0xa2b75506,                     // check integer
-        (dpiTypeFreeProc) dpiMsgProps__free
-    },
-    {
-        "dpiRowid",                     // name
-        sizeof(dpiRowid),               // size of structure
-        0x6204fa04,                     // check integer
-        (dpiTypeFreeProc) dpiRowid__free
-    },
-    {
-        "dpiContext",                   // name
-        sizeof(dpiContext),             // size of structure
-        0xd81b9181,                     // check integer
-        NULL
-    },
-    {
-        "dpiSodaColl",                  // name
-        sizeof(dpiSodaColl),            // size of structure
-        0x3684db22,                     // check integer
-        (dpiTypeFreeProc) dpiSodaColl__free
-    },
-    {
-        "dpiSodaCollCursor",            // name
-        sizeof(dpiSodaCollCursor),      // size of structure
-        0xcdc73b86,                     // check integer
-        (dpiTypeFreeProc) dpiSodaCollCursor__free
-    },
-    {
-        "dpiSodaDb",                    // name
-        sizeof(dpiSodaDb),              // size of structure
-        0x1f386121,                     // check integer
-        (dpiTypeFreeProc) dpiSodaDb__free
-    },
-    {
-        "dpiSodaDoc",                   // name
-        sizeof(dpiSodaDoc),             // size of structure
-        0xaffd950a,                     // check integer
-        (dpiTypeFreeProc) dpiSodaDoc__free
-    },
-    {
-        "dpiSodaDocCursor",             // name
-        sizeof(dpiSodaDocCursor),       // size of structure
-        0x80ceb83b,                     // check integer
-        (dpiTypeFreeProc) dpiSodaDocCursor__free
-    }
-};
-
-
-//-----------------------------------------------------------------------------
-// dpiGen__addRef() [INTERNAL]
-//   Add a reference to the specified handle.
-//-----------------------------------------------------------------------------
-int dpiGen__addRef(void *ptr, dpiHandleTypeNum typeNum, const char *fnName)
-{
-    dpiError error;
-
-    if (dpiGen__startPublicFn(ptr, typeNum, fnName, 0, &error) < 0)
-        return dpiGen__endPublicFn(ptr, DPI_FAILURE, &error);
-    dpiGen__setRefCount(ptr, &error, 1);
-    return dpiGen__endPublicFn(ptr, DPI_SUCCESS, &error);
-}
-
-
-//-----------------------------------------------------------------------------
-// dpiGen__allocate() [INTERNAL]
-//   Allocate memory for the specified type and initialize the base fields. The
-// type specified is assumed to be valid. If the environment is specified, use
-// it; otherwise, create a new one. No additional initialization is performed.
-//-----------------------------------------------------------------------------
-int dpiGen__allocate(dpiHandleTypeNum typeNum, dpiEnv *env, void **handle,
-        dpiError *error)
-{
-    const dpiTypeDef *typeDef;
-    dpiBaseType *value;
-
-    typeDef = &dpiAllTypeDefs[typeNum - DPI_HTYPE_NONE - 1];
-    if (dpiUtils__allocateMemory(1, typeDef->size, 1, "allocate handle",
-            (void**) &value, error) < 0)
-        return DPI_FAILURE;
-    value->typeDef = typeDef;
-    value->checkInt = typeDef->checkInt;
-    value->refCount = 1;
-    if (!env && typeNum != DPI_HTYPE_CONTEXT) {
-        if (dpiUtils__allocateMemory(1, sizeof(dpiEnv), 1, "allocate env",
-                (void**) &env, error) < 0) {
-            dpiUtils__freeMemory(value);
-            return DPI_FAILURE;
-        }
-    }
-    value->env = env;
-    if (dpiDebugLevel & DPI_DEBUG_LEVEL_REFS)
-        dpiDebug__print("ref %p (%s) -> 1 [NEW]\n", value, typeDef->name);
-
-    *handle = value;
-    return DPI_SUCCESS;
-}
-
-
-//-----------------------------------------------------------------------------
-// dpiGen__checkHandle() [INTERNAL]
-//   Check that the specific handle is valid, that it matches the type
-// requested and that the check integer is still in place.
-//-----------------------------------------------------------------------------
-int dpiGen__checkHandle(const void *ptr, dpiHandleTypeNum typeNum,
-        const char *action, dpiError *error)
-{
-    dpiBaseType *value = (dpiBaseType*) ptr;
-    const dpiTypeDef *typeDef;
-
-    typeDef = &dpiAllTypeDefs[typeNum - DPI_HTYPE_NONE - 1];
-    if (!ptr || value->typeDef != typeDef ||
-            value->checkInt != typeDef->checkInt)
-        return dpiError__set(error, action, DPI_ERR_INVALID_HANDLE,
-                typeDef->name);
-    return DPI_SUCCESS;
-}
-
-
-//-----------------------------------------------------------------------------
-// dpiGen__endPublicFn() [INTERNAL]
-//   This method should be the last call made in any public method using an
-// ODPI-C handle (other than dpiContext which is handled differently).
-//-----------------------------------------------------------------------------
-int dpiGen__endPublicFn(const void *ptr, int returnValue, dpiError *error)
-{
-    if (dpiDebugLevel & DPI_DEBUG_LEVEL_FNS)
-        dpiDebug__print("fn end %s(%p) -> %d\n", error->buffer->fnName, ptr,
-                returnValue);
-    if (error->handle)
-        dpiHandlePool__release(error->env->errorHandles, error->handle, error);
-
-    return returnValue;
-}
-
-
-//-----------------------------------------------------------------------------
-// dpiGen__release() [INTERNAL]
-//   Release a reference to the specified handle. If the reference count
-// reaches zero, the resources associated with the handle are released and
-// the memory associated with the handle is freed. Any internal references
-// held to other handles are also released.
-//-----------------------------------------------------------------------------
-int dpiGen__release(void *ptr, dpiHandleTypeNum typeNum, const char *fnName)
-{
-    dpiError error;
-
-    if (dpiGen__startPublicFn(ptr, typeNum, fnName, 1, &error) < 0)
-        return dpiGen__endPublicFn(ptr, DPI_FAILURE, &error);
-    dpiGen__setRefCount(ptr, &error, -1);
-    return dpiGen__endPublicFn(ptr, DPI_SUCCESS, &error);
-}
-
-
-//-----------------------------------------------------------------------------
-// dpiGen__setRefCount() [INTERNAL]
-//   Increase or decrease the reference count by the given amount. The handle
-// is assumed to be valid at this point. If the environment is in threaded
-// mode, acquire the mutex first before making any adjustments to the reference
-// count. If the operation sets the reference count to zero, release all
-// resources and free the memory associated with the structure.
-//-----------------------------------------------------------------------------
-void dpiGen__setRefCount(void *ptr, dpiError *error, int increment)
-{
-    dpiBaseType *value = (dpiBaseType*) ptr;
-    unsigned localRefCount;
-
-    // if threaded need to protect modification of the refCount with a mutex;
-    // also ensure that if the reference count reaches zero that it is
-    // immediately marked invalid in order to avoid race conditions
-    if (value->env->threaded)
-        dpiMutex__acquire(value->env->mutex);
-    value->refCount += increment;
-    localRefCount = value->refCount;
-    if (localRefCount == 0)
-        dpiUtils__clearMemory(&value->checkInt, sizeof(value->checkInt));
-    if (value->env->threaded)
-        dpiMutex__release(value->env->mutex);
-
-    // reference count debugging
-    if (dpiDebugLevel & DPI_DEBUG_LEVEL_REFS)
-        dpiDebug__print("ref %p (%s) -> %d\n", ptr, value->typeDef->name,
-                localRefCount);
-
-    // if the refCount has reached zero, call the free routine
-    if (localRefCount == 0)
-        (*value->typeDef->freeProc)(value, error);
-}
-
-
-//-----------------------------------------------------------------------------
-// dpiGen__startPublicFn() [INTERNAL]
-//   This method should be the first call made in any public method using an
-// ODPI-C handle (other than dpiContext which is handled differently). The
-// handle is checked for validity and an error handle is acquired for use in
-// all subsequent calls.
-//-----------------------------------------------------------------------------
-int dpiGen__startPublicFn(const void *ptr, dpiHandleTypeNum typeNum,
-        const char *fnName, int needErrorHandle, dpiError *error)
-{
-    dpiBaseType *value = (dpiBaseType*) ptr;
-
-    if (dpiDebugLevel & DPI_DEBUG_LEVEL_FNS)
-        dpiDebug__print("fn start %s(%p)\n", fnName, ptr);
-    if (dpiGlobal__initError(fnName, error) < 0)
-        return DPI_FAILURE;
-    if (dpiGen__checkHandle(ptr, typeNum, "check main handle", error) < 0)
-        return DPI_FAILURE;
-    if (needErrorHandle && dpiEnv__initError(value->env, error) < 0)
-        return DPI_FAILURE;
-    return DPI_SUCCESS;
-}
-

package/odpi/src/dpiGlobal.c

@@ -1,292 +0,0 @@
-//-----------------------------------------------------------------------------
-// Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
-// This program is free software: you can modify it and/or redistribute it
-// under the terms of:
-//
-// (i)  the Universal Permissive License v 1.0 or at your option, any
-//      later version (http://oss.oracle.com/licenses/upl); and/or
-//
-// (ii) the Apache License v 2.0. (http://www.apache.org/licenses/LICENSE-2.0)
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-// dpiGlobal.c
-//   Global environment used for managing errors in a thread safe manner as
-// well as for looking up encodings.
-//-----------------------------------------------------------------------------
-
-#include "dpiImpl.h"
-
-// cross platform way of defining an initializer that runs at application
-// startup (similar to what is done for the constructor calls for static C++
-// objects)
-#if defined(_MSC_VER)
-    #pragma section(".CRT$XCU", read)
-    #define DPI_INITIALIZER_HELPER(f, p) \
-        static void f(void); \
-        __declspec(allocate(".CRT$XCU")) void (*f##_)(void) = f; \
-        __pragma(comment(linker,"/include:" p #f "_")) \
-        static void f(void)
-    #ifdef _WIN64
-        #define DPI_INITIALIZER(f) DPI_INITIALIZER_HELPER(f, "")
-    #else
-        #define DPI_INITIALIZER(f) DPI_INITIALIZER_HELPER(f, "_")
-    #endif
-#else
-    #define DPI_INITIALIZER(f) \
-        static void f(void) __attribute__((constructor)); \
-        static void f(void)
-#endif
-
-// a global OCI environment is used for managing error buffers in a thread-safe
-// manner; each thread is given its own error buffer; OCI error handles,
-// though, must be created within the OCI environment created for use by
-// standalone connections and session pools
-static void *dpiGlobalEnvHandle = NULL;
-static void *dpiGlobalErrorHandle = NULL;
-static void *dpiGlobalThreadKey = NULL;
-static dpiErrorBuffer dpiGlobalErrorBuffer;
-static int dpiGlobalInitialized = 0;
-
-// a global mutex is used to ensure that only one thread is used to perform
-// initialization of ODPI-C
-static dpiMutexType dpiGlobalMutex;
-
-//-----------------------------------------------------------------------------
-// dpiGlobal__extendedInitialize() [INTERNAL]
-//   Create the global environment used for managing error buffers in a
-// thread-safe manner. This environment is solely used for implementing thread
-// local storage for the error buffers and for looking up encodings given an
-// IANA or Oracle character set name.
-//-----------------------------------------------------------------------------
-static int dpiGlobal__extendedInitialize(dpiError *error)
-{
-    int status;
-
-    // create threaded OCI environment for storing error buffers and for
-    // looking up character sets; use character set AL32UTF8 solely to avoid
-    // the overhead of processing the environment variables; no error messages
-    // from this environment are ever used (ODPI-C specific error messages are
-    // used)
-    if (dpiOci__envNlsCreate(&dpiGlobalEnvHandle, DPI_OCI_THREADED,
-            DPI_CHARSET_ID_UTF8, DPI_CHARSET_ID_UTF8, error) < 0)
-        return DPI_FAILURE;
-
-    // create global error handle
-    if (dpiOci__handleAlloc(dpiGlobalEnvHandle, &dpiGlobalErrorHandle,
-            DPI_OCI_HTYPE_ERROR, "create global error", error) < 0) {
-        dpiOci__handleFree(dpiGlobalEnvHandle, DPI_OCI_HTYPE_ENV);
-        return DPI_FAILURE;
-    }
-
-    // create global thread key
-    status = dpiOci__threadKeyInit(dpiGlobalEnvHandle, dpiGlobalErrorHandle,
-            &dpiGlobalThreadKey, (void*) dpiUtils__freeMemory, error);
-    if (status < 0) {
-        dpiOci__handleFree(dpiGlobalEnvHandle, DPI_OCI_HTYPE_ENV);
-        return DPI_FAILURE;
-    }
-
-    // mark library as fully initialized
-    dpiGlobalInitialized = 1;
-
-    return DPI_SUCCESS;
-}
-
-
-//-----------------------------------------------------------------------------
-// dpiGlobal__finalize() [INTERNAL]
-//   Called when the process terminates and ensures that everything is cleaned
-// up.
-//-----------------------------------------------------------------------------
-static void dpiGlobal__finalize(void)
-{
-    void *errorBuffer = NULL;
-    dpiError error;
-
-    dpiMutex__acquire(dpiGlobalMutex);
-    dpiGlobalInitialized = 0;
-    error.buffer = &dpiGlobalErrorBuffer;
-    if (dpiGlobalThreadKey) {
-        dpiOci__threadKeyGet(dpiGlobalEnvHandle, dpiGlobalErrorHandle,
-                dpiGlobalThreadKey, &errorBuffer, &error);
-        if (errorBuffer) {
-            dpiOci__threadKeySet(dpiGlobalEnvHandle, dpiGlobalErrorHandle,
-                    dpiGlobalThreadKey, NULL, &error);
-            dpiUtils__freeMemory(errorBuffer);
-        }
-        dpiOci__threadKeyDestroy(dpiGlobalEnvHandle, dpiGlobalErrorHandle,
-                &dpiGlobalThreadKey, &error);
-        dpiGlobalThreadKey = NULL;
-    }
-    if (dpiGlobalEnvHandle) {
-        dpiOci__handleFree(dpiGlobalEnvHandle, DPI_OCI_HTYPE_ENV);
-        dpiGlobalEnvHandle = NULL;
-    }
-    dpiMutex__release(dpiGlobalMutex);
-}
-
-
-//-----------------------------------------------------------------------------
-// dpiGlobal__initError() [INTERNAL]
-//   Get the thread local error structure for use in all other functions. If
-// an error structure cannot be determined for some reason, the global error
-// buffer structure is returned instead.
-//-----------------------------------------------------------------------------
-int dpiGlobal__initError(const char *fnName, dpiError *error)
-{
-    dpiErrorBuffer *tempErrorBuffer;
-
-    // initialize error buffer output to global error buffer structure; this is
-    // the value that is used if an error takes place before the thread local
-    // error structure can be returned
-    error->handle = NULL;
-    error->buffer = &dpiGlobalErrorBuffer;
-    if (fnName)
-        error->buffer->fnName = fnName;
-
-    // initialize global environment, if necessary
-    // this should only ever be done once by the first thread to execute this
-    if (!dpiGlobalInitialized) {
-        dpiMutex__acquire(dpiGlobalMutex);
-        if (!dpiGlobalInitialized)
-            dpiGlobal__extendedInitialize(error);
-        dpiMutex__release(dpiGlobalMutex);
-        if (!dpiGlobalInitialized)
-            return DPI_FAILURE;
-    }
-
-    // look up the error buffer specific to this thread
-    if (dpiOci__threadKeyGet(dpiGlobalEnvHandle, dpiGlobalErrorHandle,
-            dpiGlobalThreadKey, (void**) &tempErrorBuffer, error) < 0)
-        return DPI_FAILURE;
-
-    // if NULL, key has never been set for this thread, allocate new error
-    // and set it
-    if (!tempErrorBuffer) {
-        if (dpiUtils__allocateMemory(1, sizeof(dpiErrorBuffer), 1,
-                "allocate error buffer", (void**) &tempErrorBuffer, error) < 0)
-            return DPI_FAILURE;
-        if (dpiOci__threadKeySet(dpiGlobalEnvHandle, dpiGlobalErrorHandle,
-                dpiGlobalThreadKey, tempErrorBuffer, error) < 0) {
-            dpiUtils__freeMemory(tempErrorBuffer);
-            return DPI_FAILURE;
-        }
-    }
-
-    // if a function name has been specified, clear error
-    // the only time a function name is not specified is for
-    // dpiContext_getError() when the error information is being retrieved
-    if (fnName) {
-        tempErrorBuffer->code = 0;
-        tempErrorBuffer->offset = 0;
-        tempErrorBuffer->errorNum = (dpiErrorNum) 0;
-        tempErrorBuffer->isRecoverable = 0;
-        tempErrorBuffer->messageLength = 0;
-        tempErrorBuffer->fnName = fnName;
-        tempErrorBuffer->action = "start";
-        strcpy(tempErrorBuffer->encoding, DPI_CHARSET_NAME_UTF8);
-    }
-
-    error->buffer = tempErrorBuffer;
-    return DPI_SUCCESS;
-}
-
-
-//-----------------------------------------------------------------------------
-// dpiGlobal__initialize() [INTERNAL]
-//   Initialization function that runs at process startup or when the library
-// is first loaded. Some operating systems have limits on what can be run in
-// this function, so most work is done in the dpiGlobal__extendedInitialize()
-// function that runs when the first call to dpiContext_create() is made.
-//-----------------------------------------------------------------------------
-DPI_INITIALIZER(dpiGlobal__initialize)
-{
-    memset(&dpiGlobalErrorBuffer, 0, sizeof(dpiGlobalErrorBuffer));
-    strcpy(dpiGlobalErrorBuffer.encoding, DPI_CHARSET_NAME_UTF8);
-    dpiMutex__initialize(dpiGlobalMutex);
-    dpiDebug__initialize();
-    atexit(dpiGlobal__finalize);
-}
-
-
-//-----------------------------------------------------------------------------
-// dpiGlobal__lookupCharSet() [INTERNAL]
-//   Lookup the character set id that can be used in the call to
-// OCINlsEnvCreate().
-//-----------------------------------------------------------------------------
-int dpiGlobal__lookupCharSet(const char *name, uint16_t *charsetId,
-        dpiError *error)
-{
-    char oraCharsetName[DPI_OCI_NLS_MAXBUFSZ];
-
-    // check for well-known encodings first
-    if (strcmp(name, DPI_CHARSET_NAME_UTF8) == 0)
-        *charsetId = DPI_CHARSET_ID_UTF8;
-    else if (strcmp(name, DPI_CHARSET_NAME_UTF16) == 0)
-        *charsetId = DPI_CHARSET_ID_UTF16;
-    else if (strcmp(name, DPI_CHARSET_NAME_ASCII) == 0)
-        *charsetId = DPI_CHARSET_ID_ASCII;
-    else if (strcmp(name, DPI_CHARSET_NAME_UTF16LE) == 0 ||
-            strcmp(name, DPI_CHARSET_NAME_UTF16BE) == 0)
-        return dpiError__set(error, "check encoding", DPI_ERR_NOT_SUPPORTED);
-
-    // perform lookup; check for the Oracle character set name first and if
-    // that fails, lookup using the IANA character set name
-    else {
-        if (dpiOci__nlsCharSetNameToId(dpiGlobalEnvHandle, name, charsetId,
-                error) < 0)
-            return DPI_FAILURE;
-        if (!*charsetId) {
-            if (dpiOci__nlsNameMap(dpiGlobalEnvHandle, oraCharsetName,
-                    sizeof(oraCharsetName), name, DPI_OCI_NLS_CS_IANA_TO_ORA,
-                    error) < 0)
-                return dpiError__set(error, "lookup charset",
-                        DPI_ERR_INVALID_CHARSET, name);
-            dpiOci__nlsCharSetNameToId(dpiGlobalEnvHandle, oraCharsetName,
-                    charsetId, error);
-        }
-    }
-
-    return DPI_SUCCESS;
-}
-
-
-//-----------------------------------------------------------------------------
-// dpiGlobal__lookupEncoding() [INTERNAL]
-//   Get the IANA character set name (encoding) given the Oracle character set
-// id.
-//-----------------------------------------------------------------------------
-int dpiGlobal__lookupEncoding(uint16_t charsetId, char *encoding,
-        dpiError *error)
-{
-    char oracleName[DPI_OCI_NLS_MAXBUFSZ];
-
-    // check for well-known encodings first
-    switch (charsetId) {
-        case DPI_CHARSET_ID_UTF8:
-            strcpy(encoding, DPI_CHARSET_NAME_UTF8);
-            return DPI_SUCCESS;
-        case DPI_CHARSET_ID_UTF16:
-            strcpy(encoding, DPI_CHARSET_NAME_UTF16);
-            return DPI_SUCCESS;
-        case DPI_CHARSET_ID_ASCII:
-            strcpy(encoding, DPI_CHARSET_NAME_ASCII);
-            return DPI_SUCCESS;
-    }
-
-    // get character set name
-    if (dpiOci__nlsCharSetIdToName(dpiGlobalEnvHandle, oracleName,
-            sizeof(oracleName), charsetId, error) < 0)
-        return dpiError__set(error, "lookup Oracle character set name",
-                DPI_ERR_INVALID_CHARSET_ID, charsetId);
-
-    // get IANA character set name
-    if (dpiOci__nlsNameMap(dpiGlobalEnvHandle, encoding, DPI_OCI_NLS_MAXBUFSZ,
-            oracleName, DPI_OCI_NLS_CS_ORA_TO_IANA, error) < 0)
-        return dpiError__set(error, "lookup IANA name",
-                DPI_ERR_INVALID_CHARSET_ID, charsetId);
-
-    return DPI_SUCCESS;
-}
-